From 2d617b7b25ecadab020b9e3956ecba084a53cade Mon Sep 17 00:00:00 2001 From: NiteKat Date: Thu, 8 May 2025 16:45:06 -0400 Subject: [PATCH 01/32] Initial Integration of DAPI This commit adds the DAPI server,the ProtoClient that the server uses to communicate with a front end client, and the supporting SFML networking files, with the necessary CMake file changes to integrate the new files. Some code was moved from anonymous namespaces in DevilutionX to the devilution namespace so that DAPI server can access them. This builds, but crashes at the SFML initialization. --- CMake/Dependencies.cmake | 14 + CMakeSettings.json | 4 +- Source/CMakeLists.txt | 42 +- .../DAPIBackendCore/DAPIProtoClient.cpp | 213 + .../Backend/DAPIBackendCore/DAPIProtoClient.h | 47 + .../Backend/DAPIBackendCore/SFML/Config.hpp | 183 + .../Backend/DAPIBackendCore/SFML/Network.hpp | 50 + .../SFML/Network/IpAddress.cpp | 219 + .../SFML/Network/IpAddress.hpp | 296 + .../DAPIBackendCore/SFML/Network/Packet.cpp | 476 + .../DAPIBackendCore/SFML/Network/Packet.hpp | 512 + .../DAPIBackendCore/SFML/Network/Socket.cpp | 131 + .../DAPIBackendCore/SFML/Network/Socket.hpp | 211 + .../SFML/Network/SocketHandle.hpp | 54 + .../SFML/Network/SocketImpl.hpp | 38 + .../SFML/Network/SocketSelector.cpp | 188 + .../SFML/Network/SocketSelector.hpp | 255 + .../SFML/Network/TcpListener.cpp | 119 + .../SFML/Network/TcpListener.hpp | 158 + .../SFML/Network/TcpSocket.cpp | 365 + .../SFML/Network/TcpSocket.hpp | 307 + .../SFML/Network/UdpSocket.cpp | 184 + .../SFML/Network/UdpSocket.hpp | 282 + .../SFML/Network/Unix/SocketImpl.hpp | 105 + .../SFML/Network/Unix/SocketImplUnix.cpp | 102 + .../SFML/Network/Win32/SFML_Winsock.hpp | 252 + .../SFML/Network/Win32/SocketImpl.hpp | 108 + .../SFML/Network/Win32/SocketImplWin32.cpp | 167 + Source/dapi/Backend/Messages/command.proto | 180 + Source/dapi/Backend/Messages/data.proto | 178 + Source/dapi/Backend/Messages/game.proto | 36 + .../Backend/Messages/generated/command.pb.cc | 9501 ++++++++++++++ .../Backend/Messages/generated/command.pb.h | 10429 ++++++++++++++++ .../Backend/Messages/generated/data.pb.cc | 5512 ++++++++ .../dapi/Backend/Messages/generated/data.pb.h | 6992 +++++++++++ .../Backend/Messages/generated/game.pb.cc | 1115 ++ .../dapi/Backend/Messages/generated/game.pb.h | 1609 +++ .../Backend/Messages/generated/init.pb.cc | 467 + .../dapi/Backend/Messages/generated/init.pb.h | 466 + .../Backend/Messages/generated/message.pb.cc | 818 ++ .../Backend/Messages/generated/message.pb.h | 924 ++ Source/dapi/Backend/Messages/init.proto | 12 + Source/dapi/Backend/Messages/message.proto | 26 + Source/dapi/DiabloStructs.h | 0 Source/dapi/GameData.h | 47 + Source/dapi/Item.h | 72 + Source/dapi/Player.h | 74 + Source/dapi/Server.cpp | 2437 ++++ Source/dapi/Server.h | 254 + Source/dapi/Towner.h | 14 + Source/dapi/Trigger.h | 14 + Source/diablo.cpp | 4 + Source/diablo.h | 1 + Source/inv.cpp | 624 +- Source/inv.h | 4 + Source/minitext.cpp | 4 +- Source/minitext.h | 2 + Source/portal.cpp | 10 +- Source/portal.h | 2 + Source/stores.cpp | 151 +- Source/stores.h | 57 + vcpkg.json | 3 +- 62 files changed, 46709 insertions(+), 412 deletions(-) create mode 100644 Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp create mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp create mode 100644 Source/dapi/Backend/Messages/command.proto create mode 100644 Source/dapi/Backend/Messages/data.proto create mode 100644 Source/dapi/Backend/Messages/game.proto create mode 100644 Source/dapi/Backend/Messages/generated/command.pb.cc create mode 100644 Source/dapi/Backend/Messages/generated/command.pb.h create mode 100644 Source/dapi/Backend/Messages/generated/data.pb.cc create mode 100644 Source/dapi/Backend/Messages/generated/data.pb.h create mode 100644 Source/dapi/Backend/Messages/generated/game.pb.cc create mode 100644 Source/dapi/Backend/Messages/generated/game.pb.h create mode 100644 Source/dapi/Backend/Messages/generated/init.pb.cc create mode 100644 Source/dapi/Backend/Messages/generated/init.pb.h create mode 100644 Source/dapi/Backend/Messages/generated/message.pb.cc create mode 100644 Source/dapi/Backend/Messages/generated/message.pb.h create mode 100644 Source/dapi/Backend/Messages/init.proto create mode 100644 Source/dapi/Backend/Messages/message.proto create mode 100644 Source/dapi/DiabloStructs.h create mode 100644 Source/dapi/GameData.h create mode 100644 Source/dapi/Item.h create mode 100644 Source/dapi/Player.h create mode 100644 Source/dapi/Server.cpp create mode 100644 Source/dapi/Server.h create mode 100644 Source/dapi/Towner.h create mode 100644 Source/dapi/Trigger.h diff --git a/CMake/Dependencies.cmake b/CMake/Dependencies.cmake index d99355366..db5e12c52 100644 --- a/CMake/Dependencies.cmake +++ b/CMake/Dependencies.cmake @@ -56,6 +56,20 @@ if(SCREEN_READER_INTEGRATION) endif() endif() + + + + +#find_package(Protobuf REQUIRED) +#target_link_libraries(${NAME} PRIVATE protobuf::libprotobuf-lite) +#find_package(Protobuf CONFIG REQUIRED) +#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS "Source/dapi/Backend/Messages/command.proto") +#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/data.proto) +#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/game.proto) +#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/init.proto) +#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/message.proto) +#target_link_libraries(${NAME} PRIVATE protobuf)#::libprotobuf) + if(EMSCRIPTEN) # We use `USE_PTHREADS=1` here to get a version of SDL2 that supports threads. emscripten_system_library("SDL2" SDL2::SDL2 USE_SDL=2 USE_PTHREADS=1) diff --git a/CMakeSettings.json b/CMakeSettings.json index 56456356e..2041366d8 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -12,7 +12,7 @@ "variables": [ { "name": "DISCORD_INTEGRATION", - "value": "True", + "value": "False", "type": "BOOL" } ] @@ -149,4 +149,4 @@ ] } ] -} +} \ No newline at end of file diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 00621eda9..c180ecfd2 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -642,7 +642,29 @@ if(DISCORD_INTEGRATION) ) endif() -if(SCREEN_READER_INTEGRATION) +list(APPEND libdevilutionx_SRCS + dapi/Server.cpp + dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp + dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp + dapi/Backend/Messages/generated/command.pb.cc + dapi/Backend/Messages/generated/data.pb.cc + dapi/Backend/Messages/generated/game.pb.cc + dapi/Backend/Messages/generated/init.pb.cc + dapi/Backend/Messages/generated/message.pb.cc + dapi/Backend/Messages/command.proto + dapi/Backend/Messages/data.proto + dapi/Backend/Messages/game.proto + dapi/Backend/Messages/init.proto + dapi/Backend/Messages/message.proto) + + if(SCREEN_READER_INTEGRATION) list(APPEND libdevilutionx_SRCS utils/screen_reader.cpp ) @@ -789,3 +811,21 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") target_link_libraries(libdevilutionx PUBLIC c++fs) endif() endif() + +find_package(Protobuf REQUIRED) + +target_link_libraries(libdevilutionx PUBLIC protobuf::libprotobuf-lite) +find_package(absl REQUIRED) +set(PROTO_BINARY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/Messages/generated") +target_include_directories(libdevilutionx PUBLIC "$") + +#this was generating the .pb.cc/.pb.hh files for protobuf messages earlier but breaks in this current setup +#files are already generated at the moment so commenting this allows project to build. +#protobuf_generate( +# TARGET libdevilutionx +# IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/Messages" +# PROTOC_OUT_DIR "${PROTO_BINARY_DIR}") + +#include_directories("${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/DAPIBackendCore") + +target_include_directories(libdevilutionx PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/DAPIBackendCore") diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp new file mode 100644 index 000000000..7c37e5316 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp @@ -0,0 +1,213 @@ +#include "DAPIProtoClient.h" + +namespace DAPI { +DAPIProtoClient::DAPIProtoClient() + : mt(static_cast(std::chrono::system_clock::now().time_since_epoch().count())) +{ + udpbound = false; + connectionPort = 1025; +} + +void DAPIProtoClient::checkForConnection() +{ + if (isConnected()) + return; + + sf::Packet packet; + udpSocket.setBlocking(false); + if (!udpbound) { + if (udpSocket.bind(1024, sf::IpAddress::Any) != sf::Socket::Status::Done) + return; + udpbound = true; + } + + auto sender = sf::IpAddress::Any; + auto port = udpSocket.getLocalPort(); + if (udpSocket.receive(packet, sender, port) != sf::Socket::Done) + return; + + auto size = packet.getDataSize(); + std::unique_ptr packetContents(new char[size]); + memcpy(packetContents.get(), packet.getData(), size); + + auto currentMessage = std::make_unique(); + currentMessage->ParseFromArray(packetContents.get(), static_cast(size)); + + if (!currentMessage->has_initbroadcast()) + return; + + auto reply = std::make_unique(); + auto initResponse = reply->mutable_initresponse(); + + initResponse->set_port(static_cast(connectionPort)); + + packet.clear(); + size = reply->ByteSize(); + std::unique_ptr buffer(new char[size]); + + reply->SerializeToArray(&buffer[0], size); + packet.append(buffer.get(), size); + + udpSocket.send(packet, sender, port); + udpSocket.unbind(); + udpbound = false; + + tcpListener.accept(tcpSocket); + return; +} + +void DAPIProtoClient::lookForServer() +{ + if (isConnected()) + return; + + sf::Packet packet; + bool skip = false; + auto broadcastMessage = std::make_unique(); + auto initResponse = broadcastMessage->mutable_initbroadcast(); + + auto size = broadcastMessage->ByteSize(); + std::unique_ptr buffer(new char[size]); + + broadcastMessage->SerializeToArray(&buffer[0], size); + packet.append(buffer.get(), size); + + sf::IpAddress server = sf::IpAddress::Broadcast; + unsigned short port = 1024; + + udpSocket.send(packet, server, port); + server = sf::IpAddress::Any; + udpSocket.setBlocking(false); + // Sleep to give backend a chance to send the packet. + { + using namespace std::chrono_literals; + std::this_thread::sleep_for(2s); + } + if (udpSocket.receive(packet, server, port) == sf::Socket::Done) { + size = packet.getDataSize(); + std::unique_ptr replyBuffer(new char[size]); + memcpy(replyBuffer.get(), packet.getData(), size); + + auto currentMessage = std::make_unique(); + currentMessage->ParseFromArray(replyBuffer.get(), size); + + if (!currentMessage->has_initresponse()) + return; + + connectionPort = static_cast(currentMessage->initresponse().port()); + + tcpSocket.connect(server, connectionPort); + if (tcpSocket.getRemoteAddress() == sf::IpAddress::None) + fprintf(stderr, "%s", "Connection failed.\n"); + } +} + +void DAPIProtoClient::transmitMessages() +{ + // Check that we are connected to a game server. + if (!isConnected()) + return; + + std::unique_ptr currentMessage; + sf::Packet packet; + // Loop until the message queue is empty. + while (!messageQueue.empty()) { + packet.clear(); + currentMessage = std::move(messageQueue.front()); + messageQueue.pop_front(); + auto size = currentMessage->ByteSize(); + if (size > 0) { + std::unique_ptr buffer(new char[size]); + currentMessage->SerializeToArray(&buffer[0], size); + packet.append(buffer.get(), size); + } + if (tcpSocket.send(packet) != sf::Socket::Done) { + // Error sending message. + fprintf(stderr, "Failed to send a Message. Disconnecting.\n"); + disconnect(); + } + } + + // Finished with queue, send the EndOfQueue message. + currentMessage = std::make_unique(); + currentMessage->mutable_endofqueue(); + packet.clear(); + auto size = currentMessage->ByteSize(); + std::unique_ptr buffer(new char[size]); + currentMessage->SerializeToArray(&buffer[0], size); + packet.append(buffer.get(), size); + if (tcpSocket.send(packet) != sf::Socket::Done) { + // Error sending EndOfQueue + fprintf(stderr, "Failed to send end of queue message. Disconnecting.\n"); + disconnect(); + } +} + +void DAPIProtoClient::receiveMessages() +{ + // Check that we are connected to a game server or client. + if (!isConnected()) + return; + + std::unique_ptr currentMessage; + sf::Packet packet; + // Loop until the end of queue message is received. + while (true) { + packet.clear(); + currentMessage = std::make_unique(); + if (tcpSocket.receive(packet) != sf::Socket::Done) { + fprintf(stderr, "Failed to receive message. Disconnecting.\n"); + disconnect(); + return; + } + auto size = packet.getDataSize(); + std::unique_ptr packetContents(new char[size]); + memcpy(packetContents.get(), packet.getData(), size); + currentMessage->ParseFromArray(packetContents.get(), packet.getDataSize()); + if (currentMessage->has_endofqueue()) + return; + messageQueue.push_back(std::move(currentMessage)); + } +} + +void DAPIProtoClient::disconnect() +{ + if (!isConnected()) + return; + tcpSocket.disconnect(); +} + +void DAPIProtoClient::initListen() +{ + tcpListener.setBlocking(true); + while (tcpListener.listen(connectionPort) != sf::Socket::Done) + connectionPort = static_cast(getRandomInteger(1025, 49151)); +} + +void DAPIProtoClient::stopListen() +{ + tcpListener.close(); +} + +void DAPIProtoClient::queueMessage(std::unique_ptr newMessage) +{ + messageQueue.push_back(std::move(newMessage)); +} + +std::unique_ptr DAPIProtoClient::getNextMessage() +{ + auto nextMessage = std::move(messageQueue.front()); + messageQueue.pop_front(); + return nextMessage; +} + +bool DAPIProtoClient::isConnected() const +{ + return tcpSocket.getRemoteAddress() != sf::IpAddress::None; +} + +int DAPIProtoClient::messageQueueSize() const +{ + return messageQueue.size(); +} +} // namespace DAPI diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h new file mode 100644 index 000000000..b5cb2231c --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h @@ -0,0 +1,47 @@ +#pragma once + +#include +#include + +#include + +#pragma warning(push, 0) +#include "..\Messages\generated\message.pb.h" +#pragma warning(pop) + +namespace DAPI { +struct DAPIProtoClient { + DAPIProtoClient(); + + void checkForConnection(); + void lookForServer(); + void transmitMessages(); + void receiveMessages(); + void disconnect(); + void initListen(); + void stopListen(); + + void queueMessage(std::unique_ptr newMessage); + std::unique_ptr getNextMessage(); + + bool isConnected() const; + int messageQueueSize() const; + +private: + sf::UdpSocket udpSocket; + sf::TcpSocket tcpSocket; + sf::TcpListener tcpListener; + sf::SocketSelector socketSelector; + std::deque> messageQueue; + std::mt19937 mt; + + int getRandomInteger(int min, int max) + { + std::uniform_int_distribution randomNumber(min, max); + return randomNumber(mt); + } + + unsigned short connectionPort; + bool udpbound; +}; +} // namespace DAPI diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp new file mode 100644 index 000000000..a85685bb8 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp @@ -0,0 +1,183 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_CONFIG_HPP +#define SFML_CONFIG_HPP + +//////////////////////////////////////////////////////////// +// Define the SFML version +//////////////////////////////////////////////////////////// +#define SFML_VERSION_MAJOR 2 +#define SFML_VERSION_MINOR 5 +#define SFML_VERSION_PATCH 1 + +//////////////////////////////////////////////////////////// +// Identify the operating system +// see http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system +//////////////////////////////////////////////////////////// +#if defined(_WIN32) + +// Windows +#define SFML_SYSTEM_WINDOWS +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#elif defined(__APPLE__) && defined(__MACH__) + +// Apple platform, see which one it is +#include "TargetConditionals.h" + +#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR + +// iOS +#define SFML_SYSTEM_IOS + +#elif TARGET_OS_MAC + +// MacOS +#define SFML_SYSTEM_MACOS + +#else + +// Unsupported Apple system +#error This Apple operating system is not supported by SFML library + +#endif + +#elif defined(__unix__) + +// UNIX system, see which one it is +#if defined(__ANDROID__) + +// Android +#define SFML_SYSTEM_ANDROID + +#elif defined(__linux__) + +// Linux +#define SFML_SYSTEM_LINUX + +#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) + +// FreeBSD +#define SFML_SYSTEM_FREEBSD + +#elif defined(__OpenBSD__) + +// OpenBSD +#define SFML_SYSTEM_OPENBSD + +#else + +// Unsupported UNIX system +#error This UNIX operating system is not supported by SFML library + +#endif + +#else + +// Unsupported system +#error This operating system is not supported by SFML library + +#endif + +//////////////////////////////////////////////////////////// +// Define a portable debug macro +//////////////////////////////////////////////////////////// +#if !defined(NDEBUG) + +#define SFML_DEBUG + +#endif + +//////////////////////////////////////////////////////////// +// Cross-platform warning for deprecated functions and classes +// +// Usage: +// class SFML_DEPRECATED MyClass +// { +// SFML_DEPRECATED void memberFunc(); +// }; +// +// SFML_DEPRECATED void globalFunc(); +//////////////////////////////////////////////////////////// +#if defined(SFML_NO_DEPRECATED_WARNINGS) + +// User explicitly requests to disable deprecation warnings +#define SFML_DEPRECATED + +#elif defined(_MSC_VER) + +// Microsoft C++ compiler +// Note: On newer MSVC versions, using deprecated functions causes a compiler error. In order to +// trigger a warning instead of an error, the compiler flag /sdl- (instead of /sdl) must be specified. +#define SFML_DEPRECATED __declspec(deprecated) + +#elif defined(__GNUC__) + +// g++ and Clang +#define SFML_DEPRECATED __attribute__((deprecated)) + +#else + +// Other compilers are not supported, leave class or function as-is. +// With a bit of luck, the #pragma directive works, otherwise users get a warning (no error!) for unrecognized #pragma. +#pragma message("SFML_DEPRECATED is not supported for your compiler, please contact the SFML team") +#define SFML_DEPRECATED + +#endif + +//////////////////////////////////////////////////////////// +// Define portable fixed-size types +//////////////////////////////////////////////////////////// +namespace sf { +// All "common" platforms use the same size for char, short and int +// (basically there are 3 types for 3 sizes, so no other match is possible), +// we can use them without doing any kind of check + +// 8 bits integer types +typedef signed char Int8; +typedef unsigned char Uint8; + +// 16 bits integer types +typedef signed short Int16; +typedef unsigned short Uint16; + +// 32 bits integer types +typedef signed int Int32; +typedef unsigned int Uint32; + +// 64 bits integer types +#if defined(_MSC_VER) +typedef signed __int64 Int64; +typedef unsigned __int64 Uint64; +#else +typedef signed long long Int64; +typedef unsigned long long Uint64; +#endif + +} // namespace sf + +#endif // SFML_CONFIG_HPP diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp new file mode 100644 index 000000000..807e70a66 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp @@ -0,0 +1,50 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_NETWORK_HPP +#define SFML_NETWORK_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#endif // SFML_NETWORK_HPP + +//////////////////////////////////////////////////////////// +/// \defgroup network Network module +/// +/// Socket-based communication, utilities and higher-level +/// network protocols (HTTP, FTP). +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp new file mode 100644 index 000000000..f9b9af7ae --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp @@ -0,0 +1,219 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +const IpAddress IpAddress::None; +const IpAddress IpAddress::Any(0, 0, 0, 0); +const IpAddress IpAddress::LocalHost(127, 0, 0, 1); +const IpAddress IpAddress::Broadcast(255, 255, 255, 255); + +//////////////////////////////////////////////////////////// +IpAddress::IpAddress() + : m_address(0) + , m_valid(false) +{ +} + +//////////////////////////////////////////////////////////// +IpAddress::IpAddress(const std::string &address) + : m_address(0) + , m_valid(false) +{ + resolve(address); +} + +//////////////////////////////////////////////////////////// +IpAddress::IpAddress(const char *address) + : m_address(0) + , m_valid(false) +{ + resolve(address); +} + +//////////////////////////////////////////////////////////// +IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3) + : m_address(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3)) + , m_valid(true) +{ +} + +//////////////////////////////////////////////////////////// +IpAddress::IpAddress(Uint32 address) + : m_address(htonl(address)) + , m_valid(true) +{ +} + +//////////////////////////////////////////////////////////// +std::string IpAddress::toString() const +{ + in_addr address; + address.s_addr = m_address; + + return inet_ntoa(address); +} + +//////////////////////////////////////////////////////////// +Uint32 IpAddress::toInteger() const +{ + return ntohl(m_address); +} + +//////////////////////////////////////////////////////////// +IpAddress IpAddress::getLocalAddress() +{ + // The method here is to connect a UDP socket to anyone (here to localhost), + // and get the local socket address with the getsockname function. + // UDP connection will not send anything to the network, so this function won't cause any overhead. + + IpAddress localAddress; + + // Create the socket + SocketHandle sock = socket(PF_INET, SOCK_DGRAM, 0); + if (sock == priv::SocketImpl::invalidSocket()) + return localAddress; + + // Connect the socket to localhost on any port + sockaddr_in address = priv::SocketImpl::createAddress(ntohl(INADDR_LOOPBACK), 9); + if (connect(sock, reinterpret_cast(&address), sizeof(address)) == -1) { + priv::SocketImpl::close(sock); + return localAddress; + } + + // Get the local address of the socket connection + priv::SocketImpl::AddrLength size = sizeof(address); + if (getsockname(sock, reinterpret_cast(&address), &size) == -1) { + priv::SocketImpl::close(sock); + return localAddress; + } + + // Close the socket + priv::SocketImpl::close(sock); + + // Finally build the IP address + localAddress = IpAddress(ntohl(address.sin_addr.s_addr)); + + return localAddress; +} + +//////////////////////////////////////////////////////////// +void IpAddress::resolve(const std::string &address) +{ + m_address = 0; + m_valid = false; + + if (address == "255.255.255.255") { + // The broadcast address needs to be handled explicitly, + // because it is also the value returned by inet_addr on error + m_address = INADDR_BROADCAST; + m_valid = true; + } else if (address == "0.0.0.0") { + m_address = INADDR_ANY; + m_valid = true; + } else { + // Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx") + Uint32 ip = inet_addr(address.c_str()); + if (ip != INADDR_NONE) { + m_address = ip; + m_valid = true; + } else { + // Not a valid address, try to convert it as a host name + addrinfo hints; + std::memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_INET; + addrinfo *result = NULL; + if (getaddrinfo(address.c_str(), NULL, &hints, &result) == 0) { + if (result) { + ip = reinterpret_cast(result->ai_addr)->sin_addr.s_addr; + freeaddrinfo(result); + m_address = ip; + m_valid = true; + } + } + } + } +} + +//////////////////////////////////////////////////////////// +bool operator==(const IpAddress &left, const IpAddress &right) +{ + return !(left < right) && !(right < left); +} + +//////////////////////////////////////////////////////////// +bool operator!=(const IpAddress &left, const IpAddress &right) +{ + return !(left == right); +} + +//////////////////////////////////////////////////////////// +bool operator<(const IpAddress &left, const IpAddress &right) +{ + return std::make_pair(left.m_valid, left.m_address) < std::make_pair(right.m_valid, right.m_address); +} + +//////////////////////////////////////////////////////////// +bool operator>(const IpAddress &left, const IpAddress &right) +{ + return right < left; +} + +//////////////////////////////////////////////////////////// +bool operator<=(const IpAddress &left, const IpAddress &right) +{ + return !(right < left); +} + +//////////////////////////////////////////////////////////// +bool operator>=(const IpAddress &left, const IpAddress &right) +{ + return !(left < right); +} + +//////////////////////////////////////////////////////////// +std::istream &operator>>(std::istream &stream, IpAddress &address) +{ + std::string str; + stream >> str; + address = IpAddress(str); + + return stream; +} + +//////////////////////////////////////////////////////////// +std::ostream &operator<<(std::ostream &stream, const IpAddress &address) +{ + return stream << address.toString(); +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp new file mode 100644 index 000000000..d6e77ce4d --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp @@ -0,0 +1,296 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_IPADDRESS_HPP +#define SFML_IPADDRESS_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +/// \brief Encapsulate an IPv4 network address +/// +//////////////////////////////////////////////////////////// +class IpAddress { +public: + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// This constructor creates an empty (invalid) address + /// + //////////////////////////////////////////////////////////// + IpAddress(); + + //////////////////////////////////////////////////////////// + /// \brief Construct the address from a string + /// + /// Here \a address can be either a decimal address + /// (ex: "192.168.1.56") or a network name (ex: "localhost"). + /// + /// \param address IP address or network name + /// + //////////////////////////////////////////////////////////// + IpAddress(const std::string &address); + + //////////////////////////////////////////////////////////// + /// \brief Construct the address from a string + /// + /// Here \a address can be either a decimal address + /// (ex: "192.168.1.56") or a network name (ex: "localhost"). + /// This is equivalent to the constructor taking a std::string + /// parameter, it is defined for convenience so that the + /// implicit conversions from literal strings to IpAddress work. + /// + /// \param address IP address or network name + /// + //////////////////////////////////////////////////////////// + IpAddress(const char *address); + + //////////////////////////////////////////////////////////// + /// \brief Construct the address from 4 bytes + /// + /// Calling IpAddress(a, b, c, d) is equivalent to calling + /// IpAddress("a.b.c.d"), but safer as it doesn't have to + /// parse a string to get the address components. + /// + /// \param byte0 First byte of the address + /// \param byte1 Second byte of the address + /// \param byte2 Third byte of the address + /// \param byte3 Fourth byte of the address + /// + //////////////////////////////////////////////////////////// + IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3); + + //////////////////////////////////////////////////////////// + /// \brief Construct the address from a 32-bits integer + /// + /// This constructor uses the internal representation of + /// the address directly. It should be used for optimization + /// purposes, and only if you got that representation from + /// IpAddress::toInteger(). + /// + /// \param address 4 bytes of the address packed into a 32-bits integer + /// + /// \see toInteger + /// + //////////////////////////////////////////////////////////// + explicit IpAddress(Uint32 address); + + //////////////////////////////////////////////////////////// + /// \brief Get a string representation of the address + /// + /// The returned string is the decimal representation of the + /// IP address (like "192.168.1.56"), even if it was constructed + /// from a host name. + /// + /// \return String representation of the address + /// + /// \see toInteger + /// + //////////////////////////////////////////////////////////// + std::string toString() const; + + //////////////////////////////////////////////////////////// + /// \brief Get an integer representation of the address + /// + /// The returned number is the internal representation of the + /// address, and should be used for optimization purposes only + /// (like sending the address through a socket). + /// The integer produced by this function can then be converted + /// back to a sf::IpAddress with the proper constructor. + /// + /// \return 32-bits unsigned integer representation of the address + /// + /// \see toString + /// + //////////////////////////////////////////////////////////// + Uint32 toInteger() const; + + //////////////////////////////////////////////////////////// + /// \brief Get the computer's local address + /// + /// The local address is the address of the computer from the + /// LAN point of view, i.e. something like 192.168.1.56. It is + /// meaningful only for communications over the local network. + /// Unlike getPublicAddress, this function is fast and may be + /// used safely anywhere. + /// + /// \return Local IP address of the computer + /// + /// \see getPublicAddress + /// + //////////////////////////////////////////////////////////// + static IpAddress getLocalAddress(); + + //////////////////////////////////////////////////////////// + // Static member data + //////////////////////////////////////////////////////////// + static const IpAddress None; ///< Value representing an empty/invalid address + static const IpAddress Any; ///< Value representing any address (0.0.0.0) + static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally) + static const IpAddress Broadcast; ///< The "broadcast" address (for sending UDP messages to everyone on a local network) + +private: + friend bool operator<(const IpAddress &left, const IpAddress &right); + + //////////////////////////////////////////////////////////// + /// \brief Resolve the given address string + /// + /// \param address Address string + /// + //////////////////////////////////////////////////////////// + void resolve(const std::string &address); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Uint32 m_address; ///< Address stored as an unsigned 32 bits integer + bool m_valid; ///< Is the address valid? +}; + +//////////////////////////////////////////////////////////// +/// \brief Overload of == operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if both addresses are equal +/// +//////////////////////////////////////////////////////////// +bool operator==(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of != operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if both addresses are different +/// +//////////////////////////////////////////////////////////// +bool operator!=(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of < operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if \a left is lesser than \a right +/// +//////////////////////////////////////////////////////////// +bool operator<(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of > operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if \a left is greater than \a right +/// +//////////////////////////////////////////////////////////// +bool operator>(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of <= operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if \a left is lesser or equal than \a right +/// +//////////////////////////////////////////////////////////// +bool operator<=(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of >= operator to compare two IP addresses +/// +/// \param left Left operand (a IP address) +/// \param right Right operand (a IP address) +/// +/// \return True if \a left is greater or equal than \a right +/// +//////////////////////////////////////////////////////////// +bool operator>=(const IpAddress &left, const IpAddress &right); + +//////////////////////////////////////////////////////////// +/// \brief Overload of >> operator to extract an IP address from an input stream +/// +/// \param stream Input stream +/// \param address IP address to extract +/// +/// \return Reference to the input stream +/// +//////////////////////////////////////////////////////////// +std::istream &operator>>(std::istream &stream, IpAddress &address); + +//////////////////////////////////////////////////////////// +/// \brief Overload of << operator to print an IP address to an output stream +/// +/// \param stream Output stream +/// \param address IP address to print +/// +/// \return Reference to the output stream +/// +//////////////////////////////////////////////////////////// +std::ostream &operator<<(std::ostream &stream, const IpAddress &address); + +} // namespace sf + +#endif // SFML_IPADDRESS_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::IpAddress +/// \ingroup network +/// +/// sf::IpAddress is a utility class for manipulating network +/// addresses. It provides a set a implicit constructors and +/// conversion functions to easily build or transform an IP +/// address from/to various representations. +/// +/// Usage example: +/// \code +/// sf::IpAddress a0; // an invalid address +/// sf::IpAddress a1 = sf::IpAddress::None; // an invalid address (same as a0) +/// sf::IpAddress a2("127.0.0.1"); // the local host address +/// sf::IpAddress a3 = sf::IpAddress::Broadcast; // the broadcast address +/// sf::IpAddress a4(192, 168, 1, 56); // a local address +/// sf::IpAddress a5("my_computer"); // a local address created from a network name +/// sf::IpAddress a6("89.54.1.169"); // a distant address +/// sf::IpAddress a7("www.google.com"); // a distant address created from a network name +/// sf::IpAddress a8 = sf::IpAddress::getLocalAddress(); // my address on the local network +/// sf::IpAddress a9 = sf::IpAddress::getPublicAddress(); // my address on the internet +/// \endcode +/// +/// Note that sf::IpAddress currently doesn't support IPv6 +/// nor other types of network addresses. +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp new file mode 100644 index 000000000..d398b884a --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp @@ -0,0 +1,476 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +Packet::Packet() + : m_readPos(0) + , m_sendPos(0) + , m_isValid(true) +{ +} + +//////////////////////////////////////////////////////////// +Packet::~Packet() +{ +} + +//////////////////////////////////////////////////////////// +void Packet::append(const void *data, std::size_t sizeInBytes) +{ + if (data && (sizeInBytes > 0)) { + std::size_t start = m_data.size(); + m_data.resize(start + sizeInBytes); + std::memcpy(&m_data[start], data, sizeInBytes); + } +} + +//////////////////////////////////////////////////////////// +void Packet::clear() +{ + m_data.clear(); + m_readPos = 0; + m_isValid = true; +} + +//////////////////////////////////////////////////////////// +const void *Packet::getData() const +{ + return !m_data.empty() ? &m_data[0] : NULL; +} + +//////////////////////////////////////////////////////////// +std::size_t Packet::getDataSize() const +{ + return m_data.size(); +} + +//////////////////////////////////////////////////////////// +bool Packet::endOfPacket() const +{ + return m_readPos >= m_data.size(); +} + +//////////////////////////////////////////////////////////// +Packet::operator BoolType() const +{ + return m_isValid ? &Packet::checkSize : NULL; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(bool &data) +{ + Uint8 value; + if (*this >> value) + data = (value != 0); + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Int8 &data) +{ + if (checkSize(sizeof(data))) { + data = *reinterpret_cast(&m_data[m_readPos]); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Uint8 &data) +{ + if (checkSize(sizeof(data))) { + data = *reinterpret_cast(&m_data[m_readPos]); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Int16 &data) +{ + if (checkSize(sizeof(data))) { + data = ntohs(*reinterpret_cast(&m_data[m_readPos])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Uint16 &data) +{ + if (checkSize(sizeof(data))) { + data = ntohs(*reinterpret_cast(&m_data[m_readPos])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Int32 &data) +{ + if (checkSize(sizeof(data))) { + data = ntohl(*reinterpret_cast(&m_data[m_readPos])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Uint32 &data) +{ + if (checkSize(sizeof(data))) { + data = ntohl(*reinterpret_cast(&m_data[m_readPos])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Int64 &data) +{ + if (checkSize(sizeof(data))) { + // Since ntohll is not available everywhere, we have to convert + // to network byte order (big endian) manually + const Uint8 *bytes = reinterpret_cast(&m_data[m_readPos]); + data = (static_cast(bytes[0]) << 56) | (static_cast(bytes[1]) << 48) | (static_cast(bytes[2]) << 40) | (static_cast(bytes[3]) << 32) | (static_cast(bytes[4]) << 24) | (static_cast(bytes[5]) << 16) | (static_cast(bytes[6]) << 8) | (static_cast(bytes[7])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(Uint64 &data) +{ + if (checkSize(sizeof(data))) { + // Since ntohll is not available everywhere, we have to convert + // to network byte order (big endian) manually + const Uint8 *bytes = reinterpret_cast(&m_data[m_readPos]); + data = (static_cast(bytes[0]) << 56) | (static_cast(bytes[1]) << 48) | (static_cast(bytes[2]) << 40) | (static_cast(bytes[3]) << 32) | (static_cast(bytes[4]) << 24) | (static_cast(bytes[5]) << 16) | (static_cast(bytes[6]) << 8) | (static_cast(bytes[7])); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(float &data) +{ + if (checkSize(sizeof(data))) { + data = *reinterpret_cast(&m_data[m_readPos]); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(double &data) +{ + if (checkSize(sizeof(data))) { + data = *reinterpret_cast(&m_data[m_readPos]); + m_readPos += sizeof(data); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(char *data) +{ + // First extract string length + Uint32 length = 0; + *this >> length; + + if ((length > 0) && checkSize(length)) { + // Then extract characters + std::memcpy(data, &m_data[m_readPos], length); + data[length] = '\0'; + + // Update reading position + m_readPos += length; + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(std::string &data) +{ + // First extract string length + Uint32 length = 0; + *this >> length; + + data.clear(); + if ((length > 0) && checkSize(length)) { + // Then extract characters + data.assign(&m_data[m_readPos], length); + + // Update reading position + m_readPos += length; + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(wchar_t *data) +{ + // First extract string length + Uint32 length = 0; + *this >> length; + + if ((length > 0) && checkSize(length * sizeof(Uint32))) { + // Then extract characters + for (Uint32 i = 0; i < length; ++i) { + Uint32 character = 0; + *this >> character; + data[i] = static_cast(character); + } + data[length] = L'\0'; + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator>>(std::wstring &data) +{ + // First extract string length + Uint32 length = 0; + *this >> length; + + data.clear(); + if ((length > 0) && checkSize(length * sizeof(Uint32))) { + // Then extract characters + for (Uint32 i = 0; i < length; ++i) { + Uint32 character = 0; + *this >> character; + data += static_cast(character); + } + } + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(bool data) +{ + *this << static_cast(data); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Int8 data) +{ + append(&data, sizeof(data)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Uint8 data) +{ + append(&data, sizeof(data)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Int16 data) +{ + Int16 toWrite = htons(data); + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Uint16 data) +{ + Uint16 toWrite = htons(data); + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Int32 data) +{ + Int32 toWrite = htonl(data); + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Uint32 data) +{ + Uint32 toWrite = htonl(data); + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Int64 data) +{ + // Since htonll is not available everywhere, we have to convert + // to network byte order (big endian) manually + Uint8 toWrite[] = { + static_cast((data >> 56) & 0xFF), + static_cast((data >> 48) & 0xFF), + static_cast((data >> 40) & 0xFF), + static_cast((data >> 32) & 0xFF), + static_cast((data >> 24) & 0xFF), + static_cast((data >> 16) & 0xFF), + static_cast((data >> 8) & 0xFF), + static_cast((data)&0xFF) + }; + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(Uint64 data) +{ + // Since htonll is not available everywhere, we have to convert + // to network byte order (big endian) manually + Uint8 toWrite[] = { + static_cast((data >> 56) & 0xFF), + static_cast((data >> 48) & 0xFF), + static_cast((data >> 40) & 0xFF), + static_cast((data >> 32) & 0xFF), + static_cast((data >> 24) & 0xFF), + static_cast((data >> 16) & 0xFF), + static_cast((data >> 8) & 0xFF), + static_cast((data)&0xFF) + }; + append(&toWrite, sizeof(toWrite)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(float data) +{ + append(&data, sizeof(data)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(double data) +{ + append(&data, sizeof(data)); + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(const char *data) +{ + // First insert string length + Uint32 length = static_cast(std::strlen(data)); + *this << length; + + // Then insert characters + append(data, length * sizeof(char)); + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(const std::string &data) +{ + // First insert string length + Uint32 length = static_cast(data.size()); + *this << length; + + // Then insert characters + if (length > 0) + append(data.c_str(), length * sizeof(std::string::value_type)); + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(const wchar_t *data) +{ + // First insert string length + Uint32 length = static_cast(std::wcslen(data)); + *this << length; + + // Then insert characters + for (const wchar_t *c = data; *c != L'\0'; ++c) + *this << static_cast(*c); + + return *this; +} + +//////////////////////////////////////////////////////////// +Packet &Packet::operator<<(const std::wstring &data) +{ + // First insert string length + Uint32 length = static_cast(data.size()); + *this << length; + + // Then insert characters + if (length > 0) { + for (std::wstring::const_iterator c = data.begin(); c != data.end(); ++c) + *this << static_cast(*c); + } + + return *this; +} + +//////////////////////////////////////////////////////////// +bool Packet::checkSize(std::size_t size) +{ + m_isValid = m_isValid && (m_readPos + size <= m_data.size()); + + return m_isValid; +} + +//////////////////////////////////////////////////////////// +const void *Packet::onSend(std::size_t &size) +{ + size = getDataSize(); + return getData(); +} + +//////////////////////////////////////////////////////////// +void Packet::onReceive(const void *data, std::size_t size) +{ + append(data, size); +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp new file mode 100644 index 000000000..16a016cd7 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp @@ -0,0 +1,512 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_PACKET_HPP +#define SFML_PACKET_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + +namespace sf { +class TcpSocket; +class UdpSocket; + +//////////////////////////////////////////////////////////// +/// \brief Utility class to build blocks of data to transfer +/// over the network +/// +//////////////////////////////////////////////////////////// +class Packet { + // A bool-like type that cannot be converted to integer or pointer types + typedef bool (Packet::*BoolType)(std::size_t); + +public: + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// Creates an empty packet. + /// + //////////////////////////////////////////////////////////// + Packet(); + + //////////////////////////////////////////////////////////// + /// \brief Virtual destructor + /// + //////////////////////////////////////////////////////////// + virtual ~Packet(); + + //////////////////////////////////////////////////////////// + /// \brief Append data to the end of the packet + /// + /// \param data Pointer to the sequence of bytes to append + /// \param sizeInBytes Number of bytes to append + /// + /// \see clear + /// + //////////////////////////////////////////////////////////// + void append(const void *data, std::size_t sizeInBytes); + + //////////////////////////////////////////////////////////// + /// \brief Clear the packet + /// + /// After calling Clear, the packet is empty. + /// + /// \see append + /// + //////////////////////////////////////////////////////////// + void clear(); + + //////////////////////////////////////////////////////////// + /// \brief Get a pointer to the data contained in the packet + /// + /// Warning: the returned pointer may become invalid after + /// you append data to the packet, therefore it should never + /// be stored. + /// The return pointer is NULL if the packet is empty. + /// + /// \return Pointer to the data + /// + /// \see getDataSize + /// + //////////////////////////////////////////////////////////// + const void *getData() const; + + //////////////////////////////////////////////////////////// + /// \brief Get the size of the data contained in the packet + /// + /// This function returns the number of bytes pointed to by + /// what getData returns. + /// + /// \return Data size, in bytes + /// + /// \see getData + /// + //////////////////////////////////////////////////////////// + std::size_t getDataSize() const; + + //////////////////////////////////////////////////////////// + /// \brief Tell if the reading position has reached the + /// end of the packet + /// + /// This function is useful to know if there is some data + /// left to be read, without actually reading it. + /// + /// \return True if all data was read, false otherwise + /// + /// \see operator bool + /// + //////////////////////////////////////////////////////////// + bool endOfPacket() const; + +public: + //////////////////////////////////////////////////////////// + /// \brief Test the validity of the packet, for reading + /// + /// This operator allows to test the packet as a boolean + /// variable, to check if a reading operation was successful. + /// + /// A packet will be in an invalid state if it has no more + /// data to read. + /// + /// This behavior is the same as standard C++ streams. + /// + /// Usage example: + /// \code + /// float x; + /// packet >> x; + /// if (packet) + /// { + /// // ok, x was extracted successfully + /// } + /// + /// // -- or -- + /// + /// float x; + /// if (packet >> x) + /// { + /// // ok, x was extracted successfully + /// } + /// \endcode + /// + /// Don't focus on the return type, it's equivalent to bool but + /// it disallows unwanted implicit conversions to integer or + /// pointer types. + /// + /// \return True if last data extraction from packet was successful + /// + /// \see endOfPacket + /// + //////////////////////////////////////////////////////////// + operator BoolType() const; + + //////////////////////////////////////////////////////////// + /// Overload of operator >> to read data from the packet + /// + //////////////////////////////////////////////////////////// + Packet &operator>>(bool &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Int8 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Uint8 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Int16 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Uint16 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Int32 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Uint32 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Int64 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(Uint64 &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(float &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(double &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(char *data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(std::string &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(wchar_t *data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator>>(std::wstring &data); + + //////////////////////////////////////////////////////////// + /// Overload of operator << to write data into the packet + /// + //////////////////////////////////////////////////////////// + Packet &operator<<(bool data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Int8 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Uint8 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Int16 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Uint16 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Int32 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Uint32 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Int64 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(Uint64 data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(float data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(double data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(const char *data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(const std::string &data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(const wchar_t *data); + + //////////////////////////////////////////////////////////// + /// \overload + //////////////////////////////////////////////////////////// + Packet &operator<<(const std::wstring &data); + +protected: + friend class TcpSocket; + friend class UdpSocket; + + //////////////////////////////////////////////////////////// + /// \brief Called before the packet is sent over the network + /// + /// This function can be defined by derived classes to + /// transform the data before it is sent; this can be + /// used for compression, encryption, etc. + /// The function must return a pointer to the modified data, + /// as well as the number of bytes pointed. + /// The default implementation provides the packet's data + /// without transforming it. + /// + /// \param size Variable to fill with the size of data to send + /// + /// \return Pointer to the array of bytes to send + /// + /// \see onReceive + /// + //////////////////////////////////////////////////////////// + virtual const void *onSend(std::size_t &size); + + //////////////////////////////////////////////////////////// + /// \brief Called after the packet is received over the network + /// + /// This function can be defined by derived classes to + /// transform the data after it is received; this can be + /// used for decompression, decryption, etc. + /// The function receives a pointer to the received data, + /// and must fill the packet with the transformed bytes. + /// The default implementation fills the packet directly + /// without transforming the data. + /// + /// \param data Pointer to the received bytes + /// \param size Number of bytes + /// + /// \see onSend + /// + //////////////////////////////////////////////////////////// + virtual void onReceive(const void *data, std::size_t size); + +private: + //////////////////////////////////////////////////////////// + /// Disallow comparisons between packets + /// + //////////////////////////////////////////////////////////// + bool operator==(const Packet &right) const; + bool operator!=(const Packet &right) const; + + //////////////////////////////////////////////////////////// + /// \brief Check if the packet can extract a given number of bytes + /// + /// This function updates accordingly the state of the packet. + /// + /// \param size Size to check + /// + /// \return True if \a size bytes can be read from the packet + /// + //////////////////////////////////////////////////////////// + bool checkSize(std::size_t size); + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + std::vector m_data; ///< Data stored in the packet + std::size_t m_readPos; ///< Current reading position in the packet + std::size_t m_sendPos; ///< Current send position in the packet (for handling partial sends) + bool m_isValid; ///< Reading state of the packet +}; + +} // namespace sf + +#endif // SFML_PACKET_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::Packet +/// \ingroup network +/// +/// Packets provide a safe and easy way to serialize data, +/// in order to send it over the network using sockets +/// (sf::TcpSocket, sf::UdpSocket). +/// +/// Packets solve 2 fundamental problems that arise when +/// transferring data over the network: +/// \li data is interpreted correctly according to the endianness +/// \li the bounds of the packet are preserved (one send == one receive) +/// +/// The sf::Packet class provides both input and output modes. +/// It is designed to follow the behavior of standard C++ streams, +/// using operators >> and << to extract and insert data. +/// +/// It is recommended to use only fixed-size types (like sf::Int32, etc.), +/// to avoid possible differences between the sender and the receiver. +/// Indeed, the native C++ types may have different sizes on two platforms +/// and your data may be corrupted if that happens. +/// +/// Usage example: +/// \code +/// sf::Uint32 x = 24; +/// std::string s = "hello"; +/// double d = 5.89; +/// +/// // Group the variables to send into a packet +/// sf::Packet packet; +/// packet << x << s << d; +/// +/// // Send it over the network (socket is a valid sf::TcpSocket) +/// socket.send(packet); +/// +/// ----------------------------------------------------------------- +/// +/// // Receive the packet at the other end +/// sf::Packet packet; +/// socket.receive(packet); +/// +/// // Extract the variables contained in the packet +/// sf::Uint32 x; +/// std::string s; +/// double d; +/// if (packet >> x >> s >> d) +/// { +/// // Data extracted successfully... +/// } +/// \endcode +/// +/// Packets have built-in operator >> and << overloads for +/// standard types: +/// \li bool +/// \li fixed-size integer types (sf::Int8/16/32, sf::Uint8/16/32) +/// \li floating point numbers (float, double) +/// \li string types (char*, wchar_t*, std::string, std::wstring, sf::String) +/// +/// Like standard streams, it is also possible to define your own +/// overloads of operators >> and << in order to handle your +/// custom types. +/// +/// \code +/// struct MyStruct +/// { +/// float number; +/// sf::Int8 integer; +/// std::string str; +/// }; +/// +/// sf::Packet& operator <<(sf::Packet& packet, const MyStruct& m) +/// { +/// return packet << m.number << m.integer << m.str; +/// } +/// +/// sf::Packet& operator >>(sf::Packet& packet, MyStruct& m) +/// { +/// return packet >> m.number >> m.integer >> m.str; +/// } +/// \endcode +/// +/// Packets also provide an extra feature that allows to apply +/// custom transformations to the data before it is sent, +/// and after it is received. This is typically used to +/// handle automatic compression or encryption of the data. +/// This is achieved by inheriting from sf::Packet, and overriding +/// the onSend and onReceive functions. +/// +/// Here is an example: +/// \code +/// class ZipPacket : public sf::Packet +/// { +/// virtual const void* onSend(std::size_t& size) +/// { +/// const void* srcData = getData(); +/// std::size_t srcSize = getDataSize(); +/// +/// return MySuperZipFunction(srcData, srcSize, &size); +/// } +/// +/// virtual void onReceive(const void* data, std::size_t size) +/// { +/// std::size_t dstSize; +/// const void* dstData = MySuperUnzipFunction(data, size, &dstSize); +/// +/// append(dstData, dstSize); +/// } +/// }; +/// +/// // Use like regular packets: +/// ZipPacket packet; +/// packet << x << s << d; +/// ... +/// \endcode +/// +/// \see sf::TcpSocket, sf::UdpSocket +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp new file mode 100644 index 000000000..dd7a664b6 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp @@ -0,0 +1,131 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +Socket::Socket(Type type) + : m_type(type) + , m_socket(priv::SocketImpl::invalidSocket()) + , m_isBlocking(true) +{ +} + +//////////////////////////////////////////////////////////// +Socket::~Socket() +{ + // Close the socket before it gets destructed + close(); +} + +//////////////////////////////////////////////////////////// +void Socket::setBlocking(bool blocking) +{ + // Apply if the socket is already created + if (m_socket != priv::SocketImpl::invalidSocket()) + priv::SocketImpl::setBlocking(m_socket, blocking); + + m_isBlocking = blocking; +} + +//////////////////////////////////////////////////////////// +bool Socket::isBlocking() const +{ + return m_isBlocking; +} + +//////////////////////////////////////////////////////////// +SocketHandle Socket::getHandle() const +{ + return m_socket; +} + +//////////////////////////////////////////////////////////// +void Socket::create() +{ + // Don't create the socket if it already exists + if (m_socket == priv::SocketImpl::invalidSocket()) { + SocketHandle handle = socket(PF_INET, m_type == Tcp ? SOCK_STREAM : SOCK_DGRAM, 0); + + if (handle == priv::SocketImpl::invalidSocket()) { + std::cerr << "Failed to create socket" << std::endl; + return; + } + + create(handle); + } +} + +//////////////////////////////////////////////////////////// +void Socket::create(SocketHandle handle) +{ + // Don't create the socket if it already exists + if (m_socket == priv::SocketImpl::invalidSocket()) { + // Assign the new handle + m_socket = handle; + + // Set the current blocking state + setBlocking(m_isBlocking); + + if (m_type == Tcp) { + // Disable the Nagle algorithm (i.e. removes buffering of TCP packets) + int yes = 1; + if (setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&yes), sizeof(yes)) == -1) { + std::cerr << "Failed to set socket option \"TCP_NODELAY\" ; " + << "all your TCP packets will be buffered" << std::endl; + } + +// On Mac OS X, disable the SIGPIPE signal on disconnection +#ifdef SFML_SYSTEM_MACOS + if (setsockopt(m_socket, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&yes), sizeof(yes)) == -1) { + std::cerr << "Failed to set socket option \"SO_NOSIGPIPE\"" << std::endl; + } +#endif + } else { + // Enable broadcast by default for UDP sockets + int yes = 1; + if (setsockopt(m_socket, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&yes), sizeof(yes)) == -1) { + std::cerr << "Failed to enable broadcast on UDP socket" << std::endl; + } + } + } +} + +//////////////////////////////////////////////////////////// +void Socket::close() +{ + // Close the socket + if (m_socket != priv::SocketImpl::invalidSocket()) { + priv::SocketImpl::close(m_socket); + m_socket = priv::SocketImpl::invalidSocket(); + } +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp new file mode 100644 index 000000000..801c05301 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp @@ -0,0 +1,211 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SOCKET_HPP +#define SFML_SOCKET_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + +namespace sf { +class SocketSelector; + +//////////////////////////////////////////////////////////// +/// \brief Base class for all the socket types +/// +//////////////////////////////////////////////////////////// +class Socket { +public: + //////////////////////////////////////////////////////////// + /// \brief Status codes that may be returned by socket functions + /// + //////////////////////////////////////////////////////////// + enum Status { + Done, ///< The socket has sent / received the data + NotReady, ///< The socket is not ready to send / receive data yet + Partial, ///< The socket sent a part of the data + Disconnected, ///< The TCP socket has been disconnected + Error ///< An unexpected error happened + }; + + //////////////////////////////////////////////////////////// + /// \brief Some special values used by sockets + /// + //////////////////////////////////////////////////////////// + enum { + AnyPort = 0 ///< Special value that tells the system to pick any available port + }; + +public: + //////////////////////////////////////////////////////////// + /// \brief Destructor + /// + //////////////////////////////////////////////////////////// + virtual ~Socket(); + + // NonCopyable + Socket(const Socket &) = delete; + Socket(Socket &&) = delete; + Socket &operator=(const Socket &) = delete; + Socket &operator=(Socket &&) = delete; + + //////////////////////////////////////////////////////////// + /// \brief Set the blocking state of the socket + /// + /// In blocking mode, calls will not return until they have + /// completed their task. For example, a call to Receive in + /// blocking mode won't return until some data was actually + /// received. + /// In non-blocking mode, calls will always return immediately, + /// using the return code to signal whether there was data + /// available or not. + /// By default, all sockets are blocking. + /// + /// \param blocking True to set the socket as blocking, false for non-blocking + /// + /// \see isBlocking + /// + //////////////////////////////////////////////////////////// + void setBlocking(bool blocking); + + //////////////////////////////////////////////////////////// + /// \brief Tell whether the socket is in blocking or non-blocking mode + /// + /// \return True if the socket is blocking, false otherwise + /// + /// \see setBlocking + /// + //////////////////////////////////////////////////////////// + bool isBlocking() const; + +protected: + //////////////////////////////////////////////////////////// + /// \brief Types of protocols that the socket can use + /// + //////////////////////////////////////////////////////////// + enum Type { + Tcp, ///< TCP protocol + Udp ///< UDP protocol + }; + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + /// This constructor can only be accessed by derived classes. + /// + /// \param type Type of the socket (TCP or UDP) + /// + //////////////////////////////////////////////////////////// + Socket(Type type); + + //////////////////////////////////////////////////////////// + /// \brief Return the internal handle of the socket + /// + /// The returned handle may be invalid if the socket + /// was not created yet (or already destroyed). + /// This function can only be accessed by derived classes. + /// + /// \return The internal (OS-specific) handle of the socket + /// + //////////////////////////////////////////////////////////// + SocketHandle getHandle() const; + + //////////////////////////////////////////////////////////// + /// \brief Create the internal representation of the socket + /// + /// This function can only be accessed by derived classes. + /// + //////////////////////////////////////////////////////////// + void create(); + + //////////////////////////////////////////////////////////// + /// \brief Create the internal representation of the socket + /// from a socket handle + /// + /// This function can only be accessed by derived classes. + /// + /// \param handle OS-specific handle of the socket to wrap + /// + //////////////////////////////////////////////////////////// + void create(SocketHandle handle); + + //////////////////////////////////////////////////////////// + /// \brief Close the socket gracefully + /// + /// This function can only be accessed by derived classes. + /// + //////////////////////////////////////////////////////////// + void close(); + +private: + friend class SocketSelector; + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + Type m_type; ///< Type of the socket (TCP or UDP) + SocketHandle m_socket; ///< Socket descriptor + bool m_isBlocking; ///< Current blocking mode of the socket +}; + +} // namespace sf + +#endif // SFML_SOCKET_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::Socket +/// \ingroup network +/// +/// This class mainly defines internal stuff to be used by +/// derived classes. +/// +/// The only public features that it defines, and which +/// is therefore common to all the socket classes, is the +/// blocking state. All sockets can be set as blocking or +/// non-blocking. +/// +/// In blocking mode, socket functions will hang until +/// the operation completes, which means that the entire +/// program (well, in fact the current thread if you use +/// multiple ones) will be stuck waiting for your socket +/// operation to complete. +/// +/// In non-blocking mode, all the socket functions will +/// return immediately. If the socket is not ready to complete +/// the requested operation, the function simply returns +/// the proper status code (Socket::NotReady). +/// +/// The default mode, which is blocking, is the one that is +/// generally used, in combination with threads or selectors. +/// The non-blocking mode is rather used in real-time +/// applications that run an endless loop that can poll +/// the socket often enough, and cannot afford blocking +/// this loop. +/// +/// \see sf::TcpListener, sf::TcpSocket, sf::UdpSocket +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp new file mode 100644 index 000000000..a49fe9009 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp @@ -0,0 +1,54 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SOCKETHANDLE_HPP +#define SFML_SOCKETHANDLE_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include + +#if defined(SFML_SYSTEM_WINDOWS) +#include +#endif + +namespace sf { +//////////////////////////////////////////////////////////// +// Define the low-level socket handle type, specific to +// each platform +//////////////////////////////////////////////////////////// +#if defined(SFML_SYSTEM_WINDOWS) + +typedef UINT_PTR SocketHandle; + +#else + +typedef int SocketHandle; + +#endif + +} // namespace sf + +#endif // SFML_SOCKETHANDLE_HPP diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp new file mode 100644 index 000000000..72ab62e4c --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp @@ -0,0 +1,38 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include + +#if defined(SFML_SYSTEM_WINDOWS) + +#include + +#else + +#include + +#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp new file mode 100644 index 000000000..35bc5adf8 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp @@ -0,0 +1,188 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro +#endif + +namespace sf { +//////////////////////////////////////////////////////////// +struct SocketSelector::SocketSelectorImpl { + fd_set allSockets; ///< Set containing all the sockets handles + fd_set socketsReady; ///< Set containing handles of the sockets that are ready + int maxSocket; ///< Maximum socket handle + int socketCount; ///< Number of socket handles +}; + +//////////////////////////////////////////////////////////// +SocketSelector::SocketSelector() + : m_impl(new SocketSelectorImpl) +{ + clear(); +} + +//////////////////////////////////////////////////////////// +SocketSelector::SocketSelector(const SocketSelector ©) + : m_impl(new SocketSelectorImpl(*copy.m_impl)) +{ +} + +//////////////////////////////////////////////////////////// +SocketSelector::~SocketSelector() +{ + delete m_impl; +} + +//////////////////////////////////////////////////////////// +void SocketSelector::add(Socket &socket) +{ + SocketHandle handle = socket.getHandle(); + if (handle != priv::SocketImpl::invalidSocket()) { + +#if defined(SFML_SYSTEM_WINDOWS) + + if (m_impl->socketCount >= FD_SETSIZE) { + std::cerr << "The socket can't be added to the selector because the " + << "selector is full. This is a limitation of your operating " + << "system's FD_SETSIZE setting."; + return; + } + + if (FD_ISSET(handle, &m_impl->allSockets)) + return; + + m_impl->socketCount++; + +#else + + if (handle >= FD_SETSIZE) { + std::cerr << "The socket can't be added to the selector because its " + << "ID is too high. This is a limitation of your operating " + << "system's FD_SETSIZE setting."; + return; + } + + // SocketHandle is an int in POSIX + m_impl->maxSocket = std::max(m_impl->maxSocket, handle); + +#endif + + FD_SET(handle, &m_impl->allSockets); + } +} + +//////////////////////////////////////////////////////////// +void SocketSelector::remove(Socket &socket) +{ + SocketHandle handle = socket.getHandle(); + if (handle != priv::SocketImpl::invalidSocket()) { + +#if defined(SFML_SYSTEM_WINDOWS) + + if (!FD_ISSET(handle, &m_impl->allSockets)) + return; + + m_impl->socketCount--; + +#else + + if (handle >= FD_SETSIZE) + return; + +#endif + + FD_CLR(handle, &m_impl->allSockets); + FD_CLR(handle, &m_impl->socketsReady); + } +} + +//////////////////////////////////////////////////////////// +void SocketSelector::clear() +{ + FD_ZERO(&m_impl->allSockets); + FD_ZERO(&m_impl->socketsReady); + + m_impl->maxSocket = 0; + m_impl->socketCount = 0; +} + +//////////////////////////////////////////////////////////// +bool SocketSelector::wait(std::chrono::microseconds timeout) +{ + // Setup the timeout + timeval time; + time.tv_sec = static_cast(std::chrono::duration_cast(timeout).count()); + time.tv_usec = static_cast(std::chrono::duration_cast(timeout).count()); + + // Initialize the set that will contain the sockets that are ready + m_impl->socketsReady = m_impl->allSockets; + + // Wait until one of the sockets is ready for reading, or timeout is reached + // The first parameter is ignored on Windows + int count = select(m_impl->maxSocket + 1, &m_impl->socketsReady, NULL, NULL, timeout != std::chrono::microseconds::zero() ? &time : NULL); + + return count > 0; +} + +//////////////////////////////////////////////////////////// +bool SocketSelector::isReady(Socket &socket) const +{ + SocketHandle handle = socket.getHandle(); + if (handle != priv::SocketImpl::invalidSocket()) { + +#if !defined(SFML_SYSTEM_WINDOWS) + + if (handle >= FD_SETSIZE) + return false; + +#endif + + return FD_ISSET(handle, &m_impl->socketsReady) != 0; + } + + return false; +} + +//////////////////////////////////////////////////////////// +SocketSelector &SocketSelector::operator=(const SocketSelector &right) +{ + SocketSelector temp(right); + + std::swap(m_impl, temp.m_impl); + + return *this; +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp new file mode 100644 index 000000000..cb796e99a --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp @@ -0,0 +1,255 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SOCKETSELECTOR_HPP +#define SFML_SOCKETSELECTOR_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include + +namespace sf { +class Socket; + +//////////////////////////////////////////////////////////// +/// \brief Multiplexer that allows to read from multiple sockets +/// +//////////////////////////////////////////////////////////// +class SocketSelector { +public: + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + SocketSelector(); + + //////////////////////////////////////////////////////////// + /// \brief Copy constructor + /// + /// \param copy Instance to copy + /// + //////////////////////////////////////////////////////////// + SocketSelector(const SocketSelector ©); + + //////////////////////////////////////////////////////////// + /// \brief Destructor + /// + //////////////////////////////////////////////////////////// + ~SocketSelector(); + + //////////////////////////////////////////////////////////// + /// \brief Add a new socket to the selector + /// + /// This function keeps a weak reference to the socket, + /// so you have to make sure that the socket is not destroyed + /// while it is stored in the selector. + /// This function does nothing if the socket is not valid. + /// + /// \param socket Reference to the socket to add + /// + /// \see remove, clear + /// + //////////////////////////////////////////////////////////// + void add(Socket &socket); + + //////////////////////////////////////////////////////////// + /// \brief Remove a socket from the selector + /// + /// This function doesn't destroy the socket, it simply + /// removes the reference that the selector has to it. + /// + /// \param socket Reference to the socket to remove + /// + /// \see add, clear + /// + //////////////////////////////////////////////////////////// + void remove(Socket &socket); + + //////////////////////////////////////////////////////////// + /// \brief Remove all the sockets stored in the selector + /// + /// This function doesn't destroy any instance, it simply + /// removes all the references that the selector has to + /// external sockets. + /// + /// \see add, remove + /// + //////////////////////////////////////////////////////////// + void clear(); + + //////////////////////////////////////////////////////////// + /// \brief Wait until one or more sockets are ready to receive + /// + /// This function returns as soon as at least one socket has + /// some data available to be received. To know which sockets are + /// ready, use the isReady function. + /// If you use a timeout and no socket is ready before the timeout + /// is over, the function returns false. + /// + /// \param timeout Maximum time to wait, (use Time::Zero for infinity) + /// + /// \return True if there are sockets ready, false otherwise + /// + /// \see isReady + /// + //////////////////////////////////////////////////////////// + bool wait(std::chrono::microseconds timeout = std::chrono::microseconds::zero()); + + //////////////////////////////////////////////////////////// + /// \brief Test a socket to know if it is ready to receive data + /// + /// This function must be used after a call to Wait, to know + /// which sockets are ready to receive data. If a socket is + /// ready, a call to receive will never block because we know + /// that there is data available to read. + /// Note that if this function returns true for a TcpListener, + /// this means that it is ready to accept a new connection. + /// + /// \param socket Socket to test + /// + /// \return True if the socket is ready to read, false otherwise + /// + /// \see isReady + /// + //////////////////////////////////////////////////////////// + bool isReady(Socket &socket) const; + + //////////////////////////////////////////////////////////// + /// \brief Overload of assignment operator + /// + /// \param right Instance to assign + /// + /// \return Reference to self + /// + //////////////////////////////////////////////////////////// + SocketSelector &operator=(const SocketSelector &right); + +private: + struct SocketSelectorImpl; + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + SocketSelectorImpl *m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types) +}; + +} // namespace sf + +#endif // SFML_SOCKETSELECTOR_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::SocketSelector +/// \ingroup network +/// +/// Socket selectors provide a way to wait until some data is +/// available on a set of sockets, instead of just one. This +/// is convenient when you have multiple sockets that may +/// possibly receive data, but you don't know which one will +/// be ready first. In particular, it avoids to use a thread +/// for each socket; with selectors, a single thread can handle +/// all the sockets. +/// +/// All types of sockets can be used in a selector: +/// \li sf::TcpListener +/// \li sf::TcpSocket +/// \li sf::UdpSocket +/// +/// A selector doesn't store its own copies of the sockets +/// (socket classes are not copyable anyway), it simply keeps +/// a reference to the original sockets that you pass to the +/// "add" function. Therefore, you can't use the selector as a +/// socket container, you must store them outside and make sure +/// that they are alive as long as they are used in the selector. +/// +/// Using a selector is simple: +/// \li populate the selector with all the sockets that you want to observe +/// \li make it wait until there is data available on any of the sockets +/// \li test each socket to find out which ones are ready +/// +/// Usage example: +/// \code +/// // Create a socket to listen to new connections +/// sf::TcpListener listener; +/// listener.listen(55001); +/// +/// // Create a list to store the future clients +/// std::list clients; +/// +/// // Create a selector +/// sf::SocketSelector selector; +/// +/// // Add the listener to the selector +/// selector.add(listener); +/// +/// // Endless loop that waits for new connections +/// while (running) +/// { +/// // Make the selector wait for data on any socket +/// if (selector.wait()) +/// { +/// // Test the listener +/// if (selector.isReady(listener)) +/// { +/// // The listener is ready: there is a pending connection +/// sf::TcpSocket* client = new sf::TcpSocket; +/// if (listener.accept(*client) == sf::Socket::Done) +/// { +/// // Add the new client to the clients list +/// clients.push_back(client); +/// +/// // Add the new client to the selector so that we will +/// // be notified when he sends something +/// selector.add(*client); +/// } +/// else +/// { +/// // Error, we won't get a new connection, delete the socket +/// delete client; +/// } +/// } +/// else +/// { +/// // The listener socket is not ready, test all other sockets (the clients) +/// for (std::list::iterator it = clients.begin(); it != clients.end(); ++it) +/// { +/// sf::TcpSocket& client = **it; +/// if (selector.isReady(client)) +/// { +/// // The client has sent some data, we can receive it +/// sf::Packet packet; +/// if (client.receive(packet) == sf::Socket::Done) +/// { +/// ... +/// } +/// } +/// } +/// } +/// } +/// } +/// \endcode +/// +/// \see sf::Socket +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp new file mode 100644 index 000000000..d86a6e3bf --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp @@ -0,0 +1,119 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +TcpListener::TcpListener() + : Socket(Tcp) +{ +} + +//////////////////////////////////////////////////////////// +unsigned short TcpListener::getLocalPort() const +{ + if (getHandle() != priv::SocketImpl::invalidSocket()) { + // Retrieve informations about the local end of the socket + sockaddr_in address; + priv::SocketImpl::AddrLength size = sizeof(address); + if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { + return ntohs(address.sin_port); + } + } + + // We failed to retrieve the port + return 0; +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpListener::listen(unsigned short port, const IpAddress &address) +{ + // Close the socket if it is already bound + close(); + + // Create the internal socket if it doesn't exist + create(); + + // Check if the address is valid + if ((address == IpAddress::None) || (address == IpAddress::Broadcast)) + return Error; + + // Bind the socket to the specified port + sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port); + if (bind(getHandle(), reinterpret_cast(&addr), sizeof(addr)) == -1) { + // Not likely to happen, but... + std::cerr << "Failed to bind listener socket to port " << port << std::endl; + return Error; + } + + // Listen to the bound port + if (::listen(getHandle(), SOMAXCONN) == -1) { + // Oops, socket is deaf + std::cerr << "Failed to listen to port " << port << std::endl; + return Error; + } + + return Done; +} + +//////////////////////////////////////////////////////////// +void TcpListener::close() +{ + // Simply close the socket + Socket::close(); +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpListener::accept(TcpSocket &socket) +{ + // Make sure that we're listening + if (getHandle() == priv::SocketImpl::invalidSocket()) { + std::cerr << "Failed to accept a new connection, the socket is not listening" << std::endl; + return Error; + } + + // Accept a new connection + sockaddr_in address; + priv::SocketImpl::AddrLength length = sizeof(address); + SocketHandle remote = ::accept(getHandle(), reinterpret_cast(&address), &length); + + // Check for errors + if (remote == priv::SocketImpl::invalidSocket()) + return priv::SocketImpl::getErrorStatus(); + + // Initialize the new connected socket + socket.close(); + socket.create(remote); + + return Done; +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp new file mode 100644 index 000000000..d4c386311 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp @@ -0,0 +1,158 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TCPLISTENER_HPP +#define SFML_TCPLISTENER_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + +namespace sf { +class TcpSocket; + +//////////////////////////////////////////////////////////// +/// \brief Socket that listens to new TCP connections +/// +//////////////////////////////////////////////////////////// +class TcpListener : public Socket { +public: + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + TcpListener(); + + //////////////////////////////////////////////////////////// + /// \brief Get the port to which the socket is bound locally + /// + /// If the socket is not listening to a port, this function + /// returns 0. + /// + /// \return Port to which the socket is bound + /// + /// \see listen + /// + //////////////////////////////////////////////////////////// + unsigned short getLocalPort() const; + + //////////////////////////////////////////////////////////// + /// \brief Start listening for incoming connection attempts + /// + /// This function makes the socket start listening on the + /// specified port, waiting for incoming connection attempts. + /// + /// If the socket is already listening on a port when this + /// function is called, it will stop listening on the old + /// port before starting to listen on the new port. + /// + /// \param port Port to listen on for incoming connection attempts + /// \param address Address of the interface to listen on + /// + /// \return Status code + /// + /// \see accept, close + /// + //////////////////////////////////////////////////////////// + Status listen(unsigned short port, const IpAddress &address = IpAddress::Any); + + //////////////////////////////////////////////////////////// + /// \brief Stop listening and close the socket + /// + /// This function gracefully stops the listener. If the + /// socket is not listening, this function has no effect. + /// + /// \see listen + /// + //////////////////////////////////////////////////////////// + void close(); + + //////////////////////////////////////////////////////////// + /// \brief Accept a new connection + /// + /// If the socket is in blocking mode, this function will + /// not return until a connection is actually received. + /// + /// \param socket Socket that will hold the new connection + /// + /// \return Status code + /// + /// \see listen + /// + //////////////////////////////////////////////////////////// + Status accept(TcpSocket &socket); +}; + +} // namespace sf + +#endif // SFML_TCPLISTENER_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::TcpListener +/// \ingroup network +/// +/// A listener socket is a special type of socket that listens to +/// a given port and waits for connections on that port. +/// This is all it can do. +/// +/// When a new connection is received, you must call accept and +/// the listener returns a new instance of sf::TcpSocket that +/// is properly initialized and can be used to communicate with +/// the new client. +/// +/// Listener sockets are specific to the TCP protocol, +/// UDP sockets are connectionless and can therefore communicate +/// directly. As a consequence, a listener socket will always +/// return the new connections as sf::TcpSocket instances. +/// +/// A listener is automatically closed on destruction, like all +/// other types of socket. However if you want to stop listening +/// before the socket is destroyed, you can call its close() +/// function. +/// +/// Usage example: +/// \code +/// // Create a listener socket and make it wait for new +/// // connections on port 55001 +/// sf::TcpListener listener; +/// listener.listen(55001); +/// +/// // Endless loop that waits for new connections +/// while (running) +/// { +/// sf::TcpSocket client; +/// if (listener.accept(client) == sf::Socket::Done) +/// { +/// // A new client just connected! +/// std::cout << "New connection received from " << client.getRemoteAddress() << std::endl; +/// doSomethingWith(client); +/// } +/// } +/// \endcode +/// +/// \see sf::TcpSocket, sf::Socket +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp new file mode 100644 index 000000000..c3a033899 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp @@ -0,0 +1,365 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include + +#ifdef _MSC_VER +#pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro +#endif + +namespace { +// Define the low-level send/receive flags, which depend on the OS +#ifdef SFML_SYSTEM_LINUX +const int flags = MSG_NOSIGNAL; +#else +const int flags = 0; +#endif +} // namespace + +namespace sf { +//////////////////////////////////////////////////////////// +TcpSocket::TcpSocket() + : Socket(Tcp) +{ +} + +//////////////////////////////////////////////////////////// +unsigned short TcpSocket::getLocalPort() const +{ + if (getHandle() != priv::SocketImpl::invalidSocket()) { + // Retrieve informations about the local end of the socket + sockaddr_in address; + priv::SocketImpl::AddrLength size = sizeof(address); + if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { + return ntohs(address.sin_port); + } + } + + // We failed to retrieve the port + return 0; +} + +//////////////////////////////////////////////////////////// +IpAddress TcpSocket::getRemoteAddress() const +{ + if (getHandle() != priv::SocketImpl::invalidSocket()) { + // Retrieve informations about the remote end of the socket + sockaddr_in address; + priv::SocketImpl::AddrLength size = sizeof(address); + if (getpeername(getHandle(), reinterpret_cast(&address), &size) != -1) { + return IpAddress(ntohl(address.sin_addr.s_addr)); + } + } + + // We failed to retrieve the address + return IpAddress::None; +} + +//////////////////////////////////////////////////////////// +unsigned short TcpSocket::getRemotePort() const +{ + if (getHandle() != priv::SocketImpl::invalidSocket()) { + // Retrieve informations about the remote end of the socket + sockaddr_in address; + priv::SocketImpl::AddrLength size = sizeof(address); + if (getpeername(getHandle(), reinterpret_cast(&address), &size) != -1) { + return ntohs(address.sin_port); + } + } + + // We failed to retrieve the port + return 0; +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::connect(const IpAddress &remoteAddress, unsigned short remotePort, std::chrono::microseconds timeout) +{ + // Disconnect the socket if it is already connected + disconnect(); + + // Create the internal socket if it doesn't exist + create(); + + // Create the remote address + sockaddr_in address = priv::SocketImpl::createAddress(remoteAddress.toInteger(), remotePort); + + if (timeout <= std::chrono::microseconds::zero()) { + // ----- We're not using a timeout: just try to connect ----- + + // Connect the socket + if (::connect(getHandle(), reinterpret_cast(&address), sizeof(address)) == -1) + return priv::SocketImpl::getErrorStatus(); + + // Connection succeeded + return Done; + } else { + // ----- We're using a timeout: we'll need a few tricks to make it work ----- + + // Save the previous blocking state + bool blocking = isBlocking(); + + // Switch to non-blocking to enable our connection timeout + if (blocking) + setBlocking(false); + + // Try to connect to the remote address + if (::connect(getHandle(), reinterpret_cast(&address), sizeof(address)) >= 0) { + // We got instantly connected! (it may no happen a lot...) + setBlocking(blocking); + return Done; + } + + // Get the error status + Status status = priv::SocketImpl::getErrorStatus(); + + // If we were in non-blocking mode, return immediately + if (!blocking) + return status; + + // Otherwise, wait until something happens to our socket (success, timeout or error) + if (status == Socket::NotReady) { + // Setup the selector + fd_set selector; + FD_ZERO(&selector); + FD_SET(getHandle(), &selector); + + // Setup the timeout + timeval time; + time.tv_sec = static_cast(std::chrono::duration_cast(timeout).count()); + time.tv_usec = static_cast(std::chrono::duration_cast(timeout).count()); + + // Wait for something to write on our socket (which means that the connection request has returned) + if (select(static_cast(getHandle() + 1), NULL, &selector, NULL, &time) > 0) { + // At this point the connection may have been either accepted or refused. + // To know whether it's a success or a failure, we must check the address of the connected peer + if (getRemoteAddress() != IpAddress::None) { + // Connection accepted + status = Done; + } else { + // Connection refused + status = priv::SocketImpl::getErrorStatus(); + } + } else { + // Failed to connect before timeout is over + status = priv::SocketImpl::getErrorStatus(); + } + } + + // Switch back to blocking mode + setBlocking(true); + + return status; + } +} + +//////////////////////////////////////////////////////////// +void TcpSocket::disconnect() +{ + // Close the socket + close(); + + // Reset the pending packet data + m_pendingPacket = PendingPacket(); +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::send(const void *data, std::size_t size) +{ + if (!isBlocking()) + std::cerr << "Warning: Partial sends might not be handled properly." << std::endl; + + std::size_t sent; + + return send(data, size, sent); +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::send(const void *data, std::size_t size, std::size_t &sent) +{ + // Check the parameters + if (!data || (size == 0)) { + std::cerr << "Cannot send data over the network (no data to send)" << std::endl; + return Error; + } + + // Loop until every byte has been sent + int result = 0; + for (sent = 0; sent < size; sent += result) { + // Send a chunk of data + result = ::send(getHandle(), static_cast(data) + sent, static_cast(size - sent), flags); + + // Check for errors + if (result < 0) { + Status status = priv::SocketImpl::getErrorStatus(); + + if ((status == NotReady) && sent) + return Partial; + + return status; + } + } + + return Done; +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::receive(void *data, std::size_t size, std::size_t &received) +{ + // First clear the variables to fill + received = 0; + + // Check the destination buffer + if (!data) { + std::cerr << "Cannot receive data from the network (the destination buffer is invalid)" << std::endl; + return Error; + } + + // Receive a chunk of bytes + int sizeReceived = recv(getHandle(), static_cast(data), static_cast(size), flags); + + // Check the number of bytes received + if (sizeReceived > 0) { + received = static_cast(sizeReceived); + return Done; + } else if (sizeReceived == 0) { + return Socket::Disconnected; + } else { + return priv::SocketImpl::getErrorStatus(); + } +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::send(Packet &packet) +{ + // TCP is a stream protocol, it doesn't preserve messages boundaries. + // This means that we have to send the packet size first, so that the + // receiver knows the actual end of the packet in the data stream. + + // We allocate an extra memory block so that the size can be sent + // together with the data in a single call. This may seem inefficient, + // but it is actually required to avoid partial send, which could cause + // data corruption on the receiving end. + + // Get the data to send from the packet + std::size_t size = 0; + const void *data = packet.onSend(size); + + // First convert the packet size to network byte order + Uint32 packetSize = htonl(static_cast(size)); + + // Allocate memory for the data block to send + std::vector blockToSend(sizeof(packetSize) + size); + + // Copy the packet size and data into the block to send + std::memcpy(&blockToSend[0], &packetSize, sizeof(packetSize)); + if (size > 0) + std::memcpy(&blockToSend[0] + sizeof(packetSize), data, size); + + // Send the data block + std::size_t sent; + Status status = send(&blockToSend[0] + packet.m_sendPos, blockToSend.size() - packet.m_sendPos, sent); + + // In the case of a partial send, record the location to resume from + if (status == Partial) { + packet.m_sendPos += sent; + } else if (status == Done) { + packet.m_sendPos = 0; + } + + return status; +} + +//////////////////////////////////////////////////////////// +Socket::Status TcpSocket::receive(Packet &packet) +{ + // First clear the variables to fill + packet.clear(); + + // We start by getting the size of the incoming packet + Uint32 packetSize = 0; + std::size_t received = 0; + if (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { + // Loop until we've received the entire size of the packet + // (even a 4 byte variable may be received in more than one call) + while (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { + char *data = reinterpret_cast(&m_pendingPacket.Size) + m_pendingPacket.SizeReceived; + Status status = receive(data, sizeof(m_pendingPacket.Size) - m_pendingPacket.SizeReceived, received); + m_pendingPacket.SizeReceived += received; + + if (status != Done) + return status; + } + + // The packet size has been fully received + packetSize = ntohl(m_pendingPacket.Size); + } else { + // The packet size has already been received in a previous call + packetSize = ntohl(m_pendingPacket.Size); + } + + // Loop until we receive all the packet data + char buffer[1024]; + while (m_pendingPacket.Data.size() < packetSize) { + // Receive a chunk of data + std::size_t sizeToGet = std::min(static_cast(packetSize - m_pendingPacket.Data.size()), sizeof(buffer)); + Status status = receive(buffer, sizeToGet, received); + if (status != Done) + return status; + + // Append it into the packet + if (received > 0) { + m_pendingPacket.Data.resize(m_pendingPacket.Data.size() + received); + char *begin = &m_pendingPacket.Data[0] + m_pendingPacket.Data.size() - received; + std::memcpy(begin, buffer, received); + } + } + + // We have received all the packet data: we can copy it to the user packet + if (!m_pendingPacket.Data.empty()) + packet.onReceive(&m_pendingPacket.Data[0], m_pendingPacket.Data.size()); + + // Clear the pending packet data + m_pendingPacket = PendingPacket(); + + return Done; +} + +//////////////////////////////////////////////////////////// +TcpSocket::PendingPacket::PendingPacket() + : Size(0) + , SizeReceived(0) + , Data() +{ +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp new file mode 100644 index 000000000..ab74ee4fe --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp @@ -0,0 +1,307 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_TCPSOCKET_HPP +#define SFML_TCPSOCKET_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + +namespace sf { +class TcpListener; +class IpAddress; +class Packet; + +//////////////////////////////////////////////////////////// +/// \brief Specialized socket using the TCP protocol +/// +//////////////////////////////////////////////////////////// +class TcpSocket : public Socket { +public: + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + TcpSocket(); + + //////////////////////////////////////////////////////////// + /// \brief Get the port to which the socket is bound locally + /// + /// If the socket is not connected, this function returns 0. + /// + /// \return Port to which the socket is bound + /// + /// \see connect, getRemotePort + /// + //////////////////////////////////////////////////////////// + unsigned short getLocalPort() const; + + //////////////////////////////////////////////////////////// + /// \brief Get the address of the connected peer + /// + /// It the socket is not connected, this function returns + /// sf::IpAddress::None. + /// + /// \return Address of the remote peer + /// + /// \see getRemotePort + /// + //////////////////////////////////////////////////////////// + IpAddress getRemoteAddress() const; + + //////////////////////////////////////////////////////////// + /// \brief Get the port of the connected peer to which + /// the socket is connected + /// + /// If the socket is not connected, this function returns 0. + /// + /// \return Remote port to which the socket is connected + /// + /// \see getRemoteAddress + /// + //////////////////////////////////////////////////////////// + unsigned short getRemotePort() const; + + //////////////////////////////////////////////////////////// + /// \brief Connect the socket to a remote peer + /// + /// In blocking mode, this function may take a while, especially + /// if the remote peer is not reachable. The last parameter allows + /// you to stop trying to connect after a given timeout. + /// If the socket is already connected, the connection is + /// forcibly disconnected before attempting to connect again. + /// + /// \param remoteAddress Address of the remote peer + /// \param remotePort Port of the remote peer + /// \param timeout Optional maximum time to wait + /// + /// \return Status code + /// + /// \see disconnect + /// + //////////////////////////////////////////////////////////// + Status connect(const IpAddress &remoteAddress, unsigned short remotePort, std::chrono::microseconds timeout = std::chrono::microseconds::zero()); + + //////////////////////////////////////////////////////////// + /// \brief Disconnect the socket from its remote peer + /// + /// This function gracefully closes the connection. If the + /// socket is not connected, this function has no effect. + /// + /// \see connect + /// + //////////////////////////////////////////////////////////// + void disconnect(); + + //////////////////////////////////////////////////////////// + /// \brief Send raw data to the remote peer + /// + /// To be able to handle partial sends over non-blocking + /// sockets, use the send(const void*, std::size_t, std::size_t&) + /// overload instead. + /// This function will fail if the socket is not connected. + /// + /// \param data Pointer to the sequence of bytes to send + /// \param size Number of bytes to send + /// + /// \return Status code + /// + /// \see receive + /// + //////////////////////////////////////////////////////////// + Status send(const void *data, std::size_t size); + + //////////////////////////////////////////////////////////// + /// \brief Send raw data to the remote peer + /// + /// This function will fail if the socket is not connected. + /// + /// \param data Pointer to the sequence of bytes to send + /// \param size Number of bytes to send + /// \param sent The number of bytes sent will be written here + /// + /// \return Status code + /// + /// \see receive + /// + //////////////////////////////////////////////////////////// + Status send(const void *data, std::size_t size, std::size_t &sent); + + //////////////////////////////////////////////////////////// + /// \brief Receive raw data from the remote peer + /// + /// In blocking mode, this function will wait until some + /// bytes are actually received. + /// This function will fail if the socket is not connected. + /// + /// \param data Pointer to the array to fill with the received bytes + /// \param size Maximum number of bytes that can be received + /// \param received This variable is filled with the actual number of bytes received + /// + /// \return Status code + /// + /// \see send + /// + //////////////////////////////////////////////////////////// + Status receive(void *data, std::size_t size, std::size_t &received); + + //////////////////////////////////////////////////////////// + /// \brief Send a formatted packet of data to the remote peer + /// + /// In non-blocking mode, if this function returns sf::Socket::Partial, + /// you \em must retry sending the same unmodified packet before sending + /// anything else in order to guarantee the packet arrives at the remote + /// peer uncorrupted. + /// This function will fail if the socket is not connected. + /// + /// \param packet Packet to send + /// + /// \return Status code + /// + /// \see receive + /// + //////////////////////////////////////////////////////////// + Status send(Packet &packet); + + //////////////////////////////////////////////////////////// + /// \brief Receive a formatted packet of data from the remote peer + /// + /// In blocking mode, this function will wait until the whole packet + /// has been received. + /// This function will fail if the socket is not connected. + /// + /// \param packet Packet to fill with the received data + /// + /// \return Status code + /// + /// \see send + /// + //////////////////////////////////////////////////////////// + Status receive(Packet &packet); + +private: + friend class TcpListener; + + //////////////////////////////////////////////////////////// + /// \brief Structure holding the data of a pending packet + /// + //////////////////////////////////////////////////////////// + struct PendingPacket { + PendingPacket(); + + Uint32 Size; ///< Data of packet size + std::size_t SizeReceived; ///< Number of size bytes received so far + std::vector Data; ///< Data of the packet + }; + + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + PendingPacket m_pendingPacket; ///< Temporary data of the packet currently being received +}; + +} // namespace sf + +#endif // SFML_TCPSOCKET_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::TcpSocket +/// \ingroup network +/// +/// TCP is a connected protocol, which means that a TCP +/// socket can only communicate with the host it is connected +/// to. It can't send or receive anything if it is not connected. +/// +/// The TCP protocol is reliable but adds a slight overhead. +/// It ensures that your data will always be received in order +/// and without errors (no data corrupted, lost or duplicated). +/// +/// When a socket is connected to a remote host, you can +/// retrieve informations about this host with the +/// getRemoteAddress and getRemotePort functions. You can +/// also get the local port to which the socket is bound +/// (which is automatically chosen when the socket is connected), +/// with the getLocalPort function. +/// +/// Sending and receiving data can use either the low-level +/// or the high-level functions. The low-level functions +/// process a raw sequence of bytes, and cannot ensure that +/// one call to Send will exactly match one call to Receive +/// at the other end of the socket. +/// +/// The high-level interface uses packets (see sf::Packet), +/// which are easier to use and provide more safety regarding +/// the data that is exchanged. You can look at the sf::Packet +/// class to get more details about how they work. +/// +/// The socket is automatically disconnected when it is destroyed, +/// but if you want to explicitly close the connection while +/// the socket instance is still alive, you can call disconnect. +/// +/// Usage example: +/// \code +/// // ----- The client ----- +/// +/// // Create a socket and connect it to 192.168.1.50 on port 55001 +/// sf::TcpSocket socket; +/// socket.connect("192.168.1.50", 55001); +/// +/// // Send a message to the connected host +/// std::string message = "Hi, I am a client"; +/// socket.send(message.c_str(), message.size() + 1); +/// +/// // Receive an answer from the server +/// char buffer[1024]; +/// std::size_t received = 0; +/// socket.receive(buffer, sizeof(buffer), received); +/// std::cout << "The server said: " << buffer << std::endl; +/// +/// // ----- The server ----- +/// +/// // Create a listener to wait for incoming connections on port 55001 +/// sf::TcpListener listener; +/// listener.listen(55001); +/// +/// // Wait for a connection +/// sf::TcpSocket socket; +/// listener.accept(socket); +/// std::cout << "New client connected: " << socket.getRemoteAddress() << std::endl; +/// +/// // Receive a message from the client +/// char buffer[1024]; +/// std::size_t received = 0; +/// socket.receive(buffer, sizeof(buffer), received); +/// std::cout << "The client said: " << buffer << std::endl; +/// +/// // Send an answer +/// std::string message = "Welcome, client"; +/// socket.send(message.c_str(), message.size() + 1); +/// \endcode +/// +/// \see sf::Socket, sf::UdpSocket, sf::Packet +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp new file mode 100644 index 000000000..16976bbad --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp @@ -0,0 +1,184 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include + +namespace sf { +//////////////////////////////////////////////////////////// +UdpSocket::UdpSocket() + : Socket(Udp) + , m_buffer(MaxDatagramSize) +{ +} + +//////////////////////////////////////////////////////////// +unsigned short UdpSocket::getLocalPort() const +{ + if (getHandle() != priv::SocketImpl::invalidSocket()) { + // Retrieve informations about the local end of the socket + sockaddr_in address; + priv::SocketImpl::AddrLength size = sizeof(address); + if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { + return ntohs(address.sin_port); + } + } + + // We failed to retrieve the port + return 0; +} + +//////////////////////////////////////////////////////////// +Socket::Status UdpSocket::bind(unsigned short port, const IpAddress &address) +{ + // Close the socket if it is already bound + close(); + + // Create the internal socket if it doesn't exist + create(); + + // Check if the address is valid + if ((address == IpAddress::None) || (address == IpAddress::Broadcast)) + return Error; + + // Bind the socket + sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port); + if (::bind(getHandle(), reinterpret_cast(&addr), sizeof(addr)) == -1) { + std::cerr << "Failed to bind socket to port " << port << std::endl; + return Error; + } + + return Done; +} + +//////////////////////////////////////////////////////////// +void UdpSocket::unbind() +{ + // Simply close the socket + close(); +} + +//////////////////////////////////////////////////////////// +Socket::Status UdpSocket::send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort) +{ + // Create the internal socket if it doesn't exist + create(); + + // Make sure that all the data will fit in one datagram + if (size > MaxDatagramSize) { + std::cerr << "Cannot send data over the network " + << "(the number of bytes to send is greater than sf::UdpSocket::MaxDatagramSize)" << std::endl; + return Error; + } + + // Build the target address + sockaddr_in address = priv::SocketImpl::createAddress(remoteAddress.toInteger(), remotePort); + + // Send the data (unlike TCP, all the data is always sent in one call) + int sent = sendto(getHandle(), static_cast(data), static_cast(size), 0, reinterpret_cast(&address), sizeof(address)); + + // Check for errors + if (sent < 0) + return priv::SocketImpl::getErrorStatus(); + + return Done; +} + +//////////////////////////////////////////////////////////// +Socket::Status UdpSocket::receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort) +{ + // First clear the variables to fill + received = 0; + remoteAddress = IpAddress(); + remotePort = 0; + + // Check the destination buffer + if (!data) { + std::cerr << "Cannot receive data from the network (the destination buffer is invalid)" << std::endl; + return Error; + } + + // Data that will be filled with the other computer's address + sockaddr_in address = priv::SocketImpl::createAddress(INADDR_ANY, 0); + + // Receive a chunk of bytes + priv::SocketImpl::AddrLength addressSize = sizeof(address); + int sizeReceived = recvfrom(getHandle(), static_cast(data), static_cast(size), 0, reinterpret_cast(&address), &addressSize); + + // Check for errors + if (sizeReceived < 0) + return priv::SocketImpl::getErrorStatus(); + + // Fill the sender informations + received = static_cast(sizeReceived); + remoteAddress = IpAddress(ntohl(address.sin_addr.s_addr)); + remotePort = ntohs(address.sin_port); + + return Done; +} + +//////////////////////////////////////////////////////////// +Socket::Status UdpSocket::send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort) +{ + // UDP is a datagram-oriented protocol (as opposed to TCP which is a stream protocol). + // Sending one datagram is almost safe: it may be lost but if it's received, then its data + // is guaranteed to be ok. However, splitting a packet into multiple datagrams would be highly + // unreliable, since datagrams may be reordered, dropped or mixed between different sources. + // That's why SFML imposes a limit on packet size so that they can be sent in a single datagram. + // This also removes the overhead associated to packets -- there's no size to send in addition + // to the packet's data. + + // Get the data to send from the packet + std::size_t size = 0; + const void *data = packet.onSend(size); + + // Send it + return send(data, size, remoteAddress, remotePort); +} + +//////////////////////////////////////////////////////////// +Socket::Status UdpSocket::receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort) +{ + // See the detailed comment in send(Packet) above. + + // Receive the datagram + std::size_t received = 0; + Status status = receive(&m_buffer[0], m_buffer.size(), received, remoteAddress, remotePort); + + // If we received valid data, we can copy it to the user packet + packet.clear(); + if ((status == Done) && (received > 0)) + packet.onReceive(&m_buffer[0], received); + + return status; +} + +} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp new file mode 100644 index 000000000..dbb71b7c0 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp @@ -0,0 +1,282 @@ +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_UDPSOCKET_HPP +#define SFML_UDPSOCKET_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include + +namespace sf { +class Packet; + +//////////////////////////////////////////////////////////// +/// \brief Specialized socket using the UDP protocol +/// +//////////////////////////////////////////////////////////// +class UdpSocket : public Socket { +public: + //////////////////////////////////////////////////////////// + // Constants + //////////////////////////////////////////////////////////// + enum { + MaxDatagramSize = 65507 ///< The maximum number of bytes that can be sent in a single UDP datagram + }; + + //////////////////////////////////////////////////////////// + /// \brief Default constructor + /// + //////////////////////////////////////////////////////////// + UdpSocket(); + + //////////////////////////////////////////////////////////// + /// \brief Get the port to which the socket is bound locally + /// + /// If the socket is not bound to a port, this function + /// returns 0. + /// + /// \return Port to which the socket is bound + /// + /// \see bind + /// + //////////////////////////////////////////////////////////// + unsigned short getLocalPort() const; + + //////////////////////////////////////////////////////////// + /// \brief Bind the socket to a specific port + /// + /// Binding the socket to a port is necessary for being + /// able to receive data on that port. + /// You can use the special value Socket::AnyPort to tell the + /// system to automatically pick an available port, and then + /// call getLocalPort to retrieve the chosen port. + /// + /// Since the socket can only be bound to a single port at + /// any given moment, if it is already bound when this + /// function is called, it will be unbound from the previous + /// port before being bound to the new one. + /// + /// \param port Port to bind the socket to + /// \param address Address of the interface to bind to + /// + /// \return Status code + /// + /// \see unbind, getLocalPort + /// + //////////////////////////////////////////////////////////// + Status bind(unsigned short port, const IpAddress &address = IpAddress::Any); + + //////////////////////////////////////////////////////////// + /// \brief Unbind the socket from the local port to which it is bound + /// + /// The port that the socket was previously bound to is immediately + /// made available to the operating system after this function is called. + /// This means that a subsequent call to bind() will be able to re-bind + /// the port if no other process has done so in the mean time. + /// If the socket is not bound to a port, this function has no effect. + /// + /// \see bind + /// + //////////////////////////////////////////////////////////// + void unbind(); + + //////////////////////////////////////////////////////////// + /// \brief Send raw data to a remote peer + /// + /// Make sure that \a size is not greater than + /// UdpSocket::MaxDatagramSize, otherwise this function will + /// fail and no data will be sent. + /// + /// \param data Pointer to the sequence of bytes to send + /// \param size Number of bytes to send + /// \param remoteAddress Address of the receiver + /// \param remotePort Port of the receiver to send the data to + /// + /// \return Status code + /// + /// \see receive + /// + //////////////////////////////////////////////////////////// + Status send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort); + + //////////////////////////////////////////////////////////// + /// \brief Receive raw data from a remote peer + /// + /// In blocking mode, this function will wait until some + /// bytes are actually received. + /// Be careful to use a buffer which is large enough for + /// the data that you intend to receive, if it is too small + /// then an error will be returned and *all* the data will + /// be lost. + /// + /// \param data Pointer to the array to fill with the received bytes + /// \param size Maximum number of bytes that can be received + /// \param received This variable is filled with the actual number of bytes received + /// \param remoteAddress Address of the peer that sent the data + /// \param remotePort Port of the peer that sent the data + /// + /// \return Status code + /// + /// \see send + /// + //////////////////////////////////////////////////////////// + Status receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort); + + //////////////////////////////////////////////////////////// + /// \brief Send a formatted packet of data to a remote peer + /// + /// Make sure that the packet size is not greater than + /// UdpSocket::MaxDatagramSize, otherwise this function will + /// fail and no data will be sent. + /// + /// \param packet Packet to send + /// \param remoteAddress Address of the receiver + /// \param remotePort Port of the receiver to send the data to + /// + /// \return Status code + /// + /// \see receive + /// + //////////////////////////////////////////////////////////// + Status send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort); + + //////////////////////////////////////////////////////////// + /// \brief Receive a formatted packet of data from a remote peer + /// + /// In blocking mode, this function will wait until the whole packet + /// has been received. + /// + /// \param packet Packet to fill with the received data + /// \param remoteAddress Address of the peer that sent the data + /// \param remotePort Port of the peer that sent the data + /// + /// \return Status code + /// + /// \see send + /// + //////////////////////////////////////////////////////////// + Status receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort); + +private: + //////////////////////////////////////////////////////////// + // Member data + //////////////////////////////////////////////////////////// + std::vector m_buffer; ///< Temporary buffer holding the received data in Receive(Packet) +}; + +} // namespace sf + +#endif // SFML_UDPSOCKET_HPP + +//////////////////////////////////////////////////////////// +/// \class sf::UdpSocket +/// \ingroup network +/// +/// A UDP socket is a connectionless socket. Instead of +/// connecting once to a remote host, like TCP sockets, +/// it can send to and receive from any host at any time. +/// +/// It is a datagram protocol: bounded blocks of data (datagrams) +/// are transfered over the network rather than a continuous +/// stream of data (TCP). Therefore, one call to send will always +/// match one call to receive (if the datagram is not lost), +/// with the same data that was sent. +/// +/// The UDP protocol is lightweight but unreliable. Unreliable +/// means that datagrams may be duplicated, be lost or +/// arrive reordered. However, if a datagram arrives, its +/// data is guaranteed to be valid. +/// +/// UDP is generally used for real-time communication +/// (audio or video streaming, real-time games, etc.) where +/// speed is crucial and lost data doesn't matter much. +/// +/// Sending and receiving data can use either the low-level +/// or the high-level functions. The low-level functions +/// process a raw sequence of bytes, whereas the high-level +/// interface uses packets (see sf::Packet), which are easier +/// to use and provide more safety regarding the data that is +/// exchanged. You can look at the sf::Packet class to get +/// more details about how they work. +/// +/// It is important to note that UdpSocket is unable to send +/// datagrams bigger than MaxDatagramSize. In this case, it +/// returns an error and doesn't send anything. This applies +/// to both raw data and packets. Indeed, even packets are +/// unable to split and recompose data, due to the unreliability +/// of the protocol (dropped, mixed or duplicated datagrams may +/// lead to a big mess when trying to recompose a packet). +/// +/// If the socket is bound to a port, it is automatically +/// unbound from it when the socket is destroyed. However, +/// you can unbind the socket explicitly with the Unbind +/// function if necessary, to stop receiving messages or +/// make the port available for other sockets. +/// +/// Usage example: +/// \code +/// // ----- The client ----- +/// +/// // Create a socket and bind it to the port 55001 +/// sf::UdpSocket socket; +/// socket.bind(55001); +/// +/// // Send a message to 192.168.1.50 on port 55002 +/// std::string message = "Hi, I am " + sf::IpAddress::getLocalAddress().toString(); +/// socket.send(message.c_str(), message.size() + 1, "192.168.1.50", 55002); +/// +/// // Receive an answer (most likely from 192.168.1.50, but could be anyone else) +/// char buffer[1024]; +/// std::size_t received = 0; +/// sf::IpAddress sender; +/// unsigned short port; +/// socket.receive(buffer, sizeof(buffer), received, sender, port); +/// std::cout << sender.ToString() << " said: " << buffer << std::endl; +/// +/// // ----- The server ----- +/// +/// // Create a socket and bind it to the port 55002 +/// sf::UdpSocket socket; +/// socket.bind(55002); +/// +/// // Receive a message from anyone +/// char buffer[1024]; +/// std::size_t received = 0; +/// sf::IpAddress sender; +/// unsigned short port; +/// socket.receive(buffer, sizeof(buffer), received, sender, port); +/// std::cout << sender.ToString() << " said: " << buffer << std::endl; +/// +/// // Send an answer +/// std::string message = "Welcome " + sender.toString(); +/// socket.send(message.c_str(), message.size() + 1, sender, port); +/// \endcode +/// +/// \see sf::Socket, sf::TcpSocket, sf::Packet +/// +//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp new file mode 100644 index 000000000..d33cc7b27 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp @@ -0,0 +1,105 @@ +#ifndef _WIN32 +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SOCKETIMPL_HPP +#define SFML_SOCKETIMPL_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include +#include +#include +#include + +namespace sf { +namespace priv { +//////////////////////////////////////////////////////////// +/// \brief Helper class implementing all the non-portable +/// socket stuff; this is the Unix version +/// +//////////////////////////////////////////////////////////// +class SocketImpl { +public: + //////////////////////////////////////////////////////////// + // Types + //////////////////////////////////////////////////////////// + typedef socklen_t AddrLength; + + //////////////////////////////////////////////////////////// + /// \brief Create an internal sockaddr_in address + /// + /// \param address Target address + /// \param port Target port + /// + /// \return sockaddr_in ready to be used by socket functions + /// + //////////////////////////////////////////////////////////// + static sockaddr_in createAddress(Uint32 address, unsigned short port); + + //////////////////////////////////////////////////////////// + /// \brief Return the value of the invalid socket + /// + /// \return Special value of the invalid socket + /// + //////////////////////////////////////////////////////////// + static SocketHandle invalidSocket(); + + //////////////////////////////////////////////////////////// + /// \brief Close and destroy a socket + /// + /// \param sock Handle of the socket to close + /// + //////////////////////////////////////////////////////////// + static void close(SocketHandle sock); + + //////////////////////////////////////////////////////////// + /// \brief Set a socket as blocking or non-blocking + /// + /// \param sock Handle of the socket + /// \param block New blocking state of the socket + /// + //////////////////////////////////////////////////////////// + static void setBlocking(SocketHandle sock, bool block); + + //////////////////////////////////////////////////////////// + /// Get the last socket error status + /// + /// \return Status corresponding to the last socket error + /// + //////////////////////////////////////////////////////////// + static Socket::Status getErrorStatus(); +}; + +} // namespace priv + +} // namespace sf + +#endif // SFML_SOCKETIMPL_HPP +#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp new file mode 100644 index 000000000..f37cef7b7 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp @@ -0,0 +1,102 @@ +#ifndef _WIN32 +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include +#include +#include +#include + +namespace sf { +namespace priv { +//////////////////////////////////////////////////////////// +sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) +{ + sockaddr_in addr; + std::memset(&addr, 0, sizeof(addr)); + addr.sin_addr.s_addr = htonl(address); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + +#if defined(SFML_SYSTEM_MACOS) + addr.sin_len = sizeof(addr); +#endif + + return addr; +} + +//////////////////////////////////////////////////////////// +SocketHandle SocketImpl::invalidSocket() +{ + return -1; +} + +//////////////////////////////////////////////////////////// +void SocketImpl::close(SocketHandle sock) +{ + ::close(sock); +} + +//////////////////////////////////////////////////////////// +void SocketImpl::setBlocking(SocketHandle sock, bool block) +{ + int status = fcntl(sock, F_GETFL); + if (block) { + if (fcntl(sock, F_SETFL, status & ~O_NONBLOCK) == -1) + std::cerr << "Failed to set file status flags: " << errno << std::endl; + } else { + if (fcntl(sock, F_SETFL, status | O_NONBLOCK) == -1) + std::cerr << "Failed to set file status flags: " << errno << std::endl; + } +} + +//////////////////////////////////////////////////////////// +Socket::Status SocketImpl::getErrorStatus() +{ + // The followings are sometimes equal to EWOULDBLOCK, + // so we have to make a special case for them in order + // to avoid having double values in the switch case + if ((errno == EAGAIN) || (errno == EINPROGRESS)) + return Socket::NotReady; + + switch (errno) { + case EWOULDBLOCK: return Socket::NotReady; + case ECONNABORTED: return Socket::Disconnected; + case ECONNRESET: return Socket::Disconnected; + case ETIMEDOUT: return Socket::Disconnected; + case ENETRESET: return Socket::Disconnected; + case ENOTCONN: return Socket::Disconnected; + case EPIPE: return Socket::Disconnected; + default: return Socket::Error; + } +} + +} // namespace priv + +} // namespace sf +#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp new file mode 100644 index 000000000..25ef1b227 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp @@ -0,0 +1,252 @@ +#ifndef WIN32_LEAN_AND_MEAN +#define WIN32_LEAN_AND_MEAN +#endif + +#ifndef NOGDICAPMASKS +#define NOGDICAPMASKS +#endif + +#ifndef NOVIRTUALKEYCODES +#define NOVIRTUALKEYCODES +#endif + +#ifndef NOWINMESSAGES +#define NOWINMESSAGES +#endif + +#ifndef NOWINSTYLES +#define NOWINSTYLES +#endif + +#ifndef NOSYSMETRICS +#define NOSYSMETRICS +#endif + +#ifndef NOMENUS +#define NOMENUS +#endif + +#ifndef NOICONS +#define NOICONS +#endif + +#ifndef NOKEYSTATES +#define NOKEYSTATES +#endif + +#ifndef NOSYSCOMMANDS +#define NOSYSCOMMANDS +#endif + +#ifndef NORASTEROPS +#define NORASTEROPS +#endif + +#ifndef NOSHOWWINDOW +#define NOSHOWWINDOW +#endif + +#ifndef NOATOM +#define NOATOM +#endif + +#ifndef NOCLIPBOARD +#define NOCLIPBOARD +#endif + +#ifndef NOCOLOR +#define NOCOLOR +#endif + +#ifndef NOCTLMGR +#define NOCTLMGR +#endif + +#ifndef NODRAWTEXT +#define NODRAWTEXT +#endif + +#ifndef NOGDI +#define NOGDI +#endif + +#ifndef NOKERNEL +#define NOKERNEL +#endif + +#ifndef NOUSER +#define NOUSER +#endif + +#ifndef NONLS +#define NONLS +#endif + +#ifndef NOMB +#define NOMB +#endif + +#ifndef NOMEMMGR +#define NOMEMMGR +#endif + +#ifndef NOMETAFILE +#define NOMETAFILE +#endif + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +#ifndef NOMSG +#define NOMSG +#endif + +#ifndef NOOPENFILE +#define NOOPENFILE +#endif + +#ifndef NOSCROLL +#define NOSCROLL +#endif + +#ifndef NOSERVICE +#define NOSERVICE +#endif + +#ifndef NOSOUND +#define NOSOUND +#endif + +#ifndef NOTEXTMETRIC +#define NOTEXTMETRIC +#endif + +#ifndef NOWH +#define NOWH +#endif + +#ifndef NOWINOFFSETS +#define NOWINOFFSETS +#endif + +#ifndef NOCOMM +#define NOCOMM +#endif + +#ifndef NOKANJI +#define NOKANJI +#endif + +#ifndef NOHELP +#define NOHELP +#endif + +#ifndef NOPROFILER +#define NOPROFILER +#endif + +#ifndef NODEFERWINDOWPOS +#define NODEFERWINDOWPOS +#endif + +#ifndef NOMCX +#define NOMCX +#endif + +#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS +#define _WINSOCK_DEPRECATED_NO_WARNINGS +#endif + +#define recvfrom recvfrom_original +#define setsockopt setsockopt_original +#define socket socket_original +#define select select_original +#define WSAGetLastError WSAGetLastError_original +#define ioctlsocket ioctlsocket_original +#define htons htons_original +#define htonl htonl_original +#define WSAStartup WSAStartup_original +#define closesocket closesocket_original +#define WSACleanup WSACleanup_original +#define ntohs ntohs_original +#define getsockname getsockname_original +#define listen listen_original +#define bind bind_original +#define accept accept_original +#define ntohl ntohl_original +#define recv recv_original +#define connect connect_original +#define send send_original +#define getpeername getpeername_original +#define freeaddrinfo freeaddrinfo_original +#define inet_ntoa inet_ntoa_original +#define inet_addr inet_addr_original +#define getaddrinfo getaddrinfo_original +#define sendto sendto_original +#define __WSAFDIsSet __WSAFDIsSet_original + +#include +#include + +#undef recvfrom +#undef setsockopt +#undef socket +#undef select +#undef WSAGetLastError +#undef ioctlsocket +#undef htons +#undef htonl +#undef WSAStartup +#undef closesocket +#undef WSACleanup +#undef ntohs +#undef getsockname +#undef listen +#undef bind +#undef accept +#undef ntohl +#undef recv +#undef connect +#undef send +#undef getpeername +#undef freeaddrinfo +#undef inet_ntoa +#undef inet_addr +#undef getaddrinfo +#undef sendto +#undef __WSAFDIsSet + +extern decltype(recvfrom_original) *recvfrom; +extern decltype(setsockopt_original) *setsockopt; +extern decltype(socket_original) *socket; +extern decltype(select_original) *select; +extern decltype(WSAGetLastError_original) *WSAGetLastError; +extern decltype(ioctlsocket_original) *ioctlsocket; +extern decltype(htons_original) *htons; +extern decltype(htonl_original) *htonl; +extern decltype(WSAStartup_original) *WSAStartup; +extern decltype(closesocket_original) *closesocket; +extern decltype(WSACleanup_original) *WSACleanup; +extern decltype(ntohs_original) *ntohs; +extern decltype(getsockname_original) *getsockname; +extern decltype(listen_original) *listen; +extern decltype(bind_original) *bind; +extern decltype(accept_original) *accept; +extern decltype(ntohl_original) *ntohl; +extern decltype(recv_original) *recv; +extern decltype(connect_original) *connect; +extern decltype(send_original) *send; +extern decltype(getpeername_original) *getpeername; +extern decltype(freeaddrinfo_original) *freeaddrinfo; +extern decltype(inet_ntoa_original) *inet_ntoa; +extern decltype(inet_addr_original) *inet_addr; +extern decltype(getaddrinfo_original) *getaddrinfo; +extern decltype(sendto_original) *sendto; +extern decltype(__WSAFDIsSet_original) *__WSAFDIsSet; + +#ifdef FD_ISSET +#undef FD_ISSET +#endif + +#define FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set FAR *)(set)) diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp new file mode 100644 index 000000000..400796567 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp @@ -0,0 +1,108 @@ +#ifdef _WIN32 +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +#ifndef SFML_SOCKETIMPL_HPP +#define SFML_SOCKETIMPL_HPP + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#ifdef _WIN32_WINDOWS +#undef _WIN32_WINDOWS +#endif +#ifdef _WIN32_WINNT +#undef _WIN32_WINNT +#endif +#define _WIN32_WINDOWS 0x0501 +#define _WIN32_WINNT 0x0501 + +#include "SFML_Winsock.hpp" +#include + +namespace sf { +namespace priv { +//////////////////////////////////////////////////////////// +/// \brief Helper class implementing all the non-portable +/// socket stuff; this is the Windows version +/// +//////////////////////////////////////////////////////////// +class SocketImpl { +public: + //////////////////////////////////////////////////////////// + // Types + //////////////////////////////////////////////////////////// + typedef int AddrLength; + + //////////////////////////////////////////////////////////// + /// \brief Create an internal sockaddr_in address + /// + /// \param address Target address + /// \param port Target port + /// + /// \return sockaddr_in ready to be used by socket functions + /// + //////////////////////////////////////////////////////////// + static sockaddr_in createAddress(Uint32 address, unsigned short port); + + //////////////////////////////////////////////////////////// + /// \brief Return the value of the invalid socket + /// + /// \return Special value of the invalid socket + /// + //////////////////////////////////////////////////////////// + static SocketHandle invalidSocket(); + + //////////////////////////////////////////////////////////// + /// \brief Close and destroy a socket + /// + /// \param sock Handle of the socket to close + /// + //////////////////////////////////////////////////////////// + static void close(SocketHandle sock); + + //////////////////////////////////////////////////////////// + /// \brief Set a socket as blocking or non-blocking + /// + /// \param sock Handle of the socket + /// \param block New blocking state of the socket + /// + //////////////////////////////////////////////////////////// + static void setBlocking(SocketHandle sock, bool block); + + //////////////////////////////////////////////////////////// + /// Get the last socket error status + /// + /// \return Status corresponding to the last socket error + /// + //////////////////////////////////////////////////////////// + static Socket::Status getErrorStatus(); +}; + +} // namespace priv + +} // namespace sf + +#endif // SFML_SOCKETIMPL_HPP +#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp new file mode 100644 index 000000000..ad1026152 --- /dev/null +++ b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp @@ -0,0 +1,167 @@ +#ifdef _WIN32 +//////////////////////////////////////////////////////////// +// +// SFML - Simple and Fast Multimedia Library +// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) +// +// This software is provided 'as-is', without any express or implied warranty. +// In no event will the authors be held liable for any damages arising from the use of this software. +// +// Permission is granted to anyone to use this software for any purpose, +// including commercial applications, and to alter it and redistribute it freely, +// subject to the following restrictions: +// +// 1. The origin of this software must not be misrepresented; +// you must not claim that you wrote the original software. +// If you use this software in a product, an acknowledgment +// in the product documentation would be appreciated but is not required. +// +// 2. Altered source versions must be plainly marked as such, +// and must not be misrepresented as being the original software. +// +// 3. This notice may not be removed or altered from any source distribution. +// +//////////////////////////////////////////////////////////// + +//////////////////////////////////////////////////////////// +// Headers +//////////////////////////////////////////////////////////// +#include +#include + +decltype(recvfrom_original) *recvfrom; +decltype(setsockopt_original) *setsockopt; +decltype(socket_original) *socket; +decltype(select_original) *select; +decltype(WSAGetLastError_original) *WSAGetLastError; +decltype(ioctlsocket_original) *ioctlsocket; +decltype(htons_original) *htons; +decltype(htonl_original) *htonl; +decltype(WSAStartup_original) *WSAStartup; +decltype(closesocket_original) *closesocket; +decltype(WSACleanup_original) *WSACleanup; +decltype(ntohs_original) *ntohs; +decltype(getsockname_original) *getsockname; +decltype(listen_original) *listen; +decltype(bind_original) *bind; +decltype(accept_original) *accept; +decltype(ntohl_original) *ntohl; +decltype(recv_original) *recv; +decltype(connect_original) *connect; +decltype(send_original) *send; +decltype(getpeername_original) *getpeername; +decltype(freeaddrinfo_original) *freeaddrinfo; +decltype(inet_ntoa_original) *inet_ntoa; +decltype(inet_addr_original) *inet_addr; +decltype(getaddrinfo_original) *getaddrinfo; +decltype(sendto_original) *sendto; +decltype(__WSAFDIsSet_original) *__WSAFDIsSet; + +namespace sf { +namespace priv { + +//////////////////////////////////////////////////////////// +// Windows needs some initialization and cleanup to get +// sockets working properly... so let's create a class that will +// do it automatically +//////////////////////////////////////////////////////////// +struct WSock32 { + WSock32() + { + ws2_32 = LoadLibrary(TEXT("ws2_32.dll")); + + (FARPROC &)recvfrom = GetProcAddress(ws2_32, "recvfrom"); + (FARPROC &)setsockopt = GetProcAddress(ws2_32, "setsockopt"); + (FARPROC &)socket = GetProcAddress(ws2_32, "socket"); + (FARPROC &)select = GetProcAddress(ws2_32, "select"); + (FARPROC &)WSAGetLastError = GetProcAddress(ws2_32, "WSAGetLastError"); + (FARPROC &)ioctlsocket = GetProcAddress(ws2_32, "ioctlsocket"); + (FARPROC &)htons = GetProcAddress(ws2_32, "htons"); + (FARPROC &)htonl = GetProcAddress(ws2_32, "htonl"); + (FARPROC &)WSAStartup = GetProcAddress(ws2_32, "WSAStartup"); + (FARPROC &)closesocket = GetProcAddress(ws2_32, "closesocket"); + (FARPROC &)WSACleanup = GetProcAddress(ws2_32, "WSACleanup"); + (FARPROC &)ntohs = GetProcAddress(ws2_32, "ntohs"); + (FARPROC &)getsockname = GetProcAddress(ws2_32, "getsockname"); + (FARPROC &)listen = GetProcAddress(ws2_32, "listen"); + (FARPROC &)bind = GetProcAddress(ws2_32, "bind"); + (FARPROC &)accept = GetProcAddress(ws2_32, "accept"); + (FARPROC &)ntohl = GetProcAddress(ws2_32, "ntohl"); + (FARPROC &)recv = GetProcAddress(ws2_32, "recv"); + (FARPROC &)connect = GetProcAddress(ws2_32, "connect"); + (FARPROC &)send = GetProcAddress(ws2_32, "send"); + (FARPROC &)getpeername = GetProcAddress(ws2_32, "getpeername"); + (FARPROC &)freeaddrinfo = GetProcAddress(ws2_32, "freeaddrinfo"); + (FARPROC &)inet_ntoa = GetProcAddress(ws2_32, "inet_ntoa"); + (FARPROC &)inet_addr = GetProcAddress(ws2_32, "inet_addr"); + (FARPROC &)getaddrinfo = GetProcAddress(ws2_32, "getaddrinfo"); + (FARPROC &)sendto = GetProcAddress(ws2_32, "sendto"); + (FARPROC &)__WSAFDIsSet = GetProcAddress(ws2_32, "__WSAFDIsSet"); + + WSADATA init; + WSAStartup(MAKEWORD(2, 2), &init); + } + + ~WSock32() + { + WSACleanup(); + + FreeLibrary(ws2_32); + } + + HMODULE ws2_32; +}; + +WSock32 wsock32; + +//////////////////////////////////////////////////////////// +sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) +{ + sockaddr_in addr; + std::memset(&addr, 0, sizeof(addr)); + addr.sin_addr.s_addr = htonl(address); + addr.sin_family = AF_INET; + addr.sin_port = htons(port); + + return addr; +} + +//////////////////////////////////////////////////////////// +SocketHandle SocketImpl::invalidSocket() +{ + return INVALID_SOCKET; +} + +//////////////////////////////////////////////////////////// +void SocketImpl::close(SocketHandle sock) +{ + closesocket(sock); +} + +//////////////////////////////////////////////////////////// +void SocketImpl::setBlocking(SocketHandle sock, bool block) +{ + u_long blocking = block ? 0 : 1; + ioctlsocket(sock, FIONBIO, &blocking); +} + +//////////////////////////////////////////////////////////// +Socket::Status SocketImpl::getErrorStatus() +{ + switch (WSAGetLastError()) { + case WSAEWOULDBLOCK: return Socket::NotReady; + case WSAEALREADY: return Socket::NotReady; + case WSAECONNABORTED: return Socket::Disconnected; + case WSAECONNRESET: return Socket::Disconnected; + case WSAETIMEDOUT: return Socket::Disconnected; + case WSAENETRESET: return Socket::Disconnected; + case WSAENOTCONN: return Socket::Disconnected; + case WSAEISCONN: return Socket::Done; // when connecting a non-blocking socket + default: return Socket::Error; + } +} + +} // namespace priv + +} // namespace sf +#endif diff --git a/Source/dapi/Backend/Messages/command.proto b/Source/dapi/Backend/Messages/command.proto new file mode 100644 index 000000000..ced3e1f05 --- /dev/null +++ b/Source/dapi/Backend/Messages/command.proto @@ -0,0 +1,180 @@ +syntax = "proto3"; +option optimize_for = LITE_RUNTIME; + +package dapi.commands; + +message SetFPS { + uint32 FPS = 1; +} + +message CancelQText { + +} + +message Move { + uint32 type = 1; + uint32 targetX = 2; + uint32 targetY = 3; +} + +message Talk { + uint32 targetX = 1; + uint32 targetY = 2; +} + +message SelectStoreOption { + uint32 option = 1; +} + +message BuyItem { + uint32 ID = 1; +} + +message SellItem { + uint32 ID = 1; +} + +message RechargeItem { + uint32 ID = 1; +} + +message RepairItem { + uint32 ID = 1; +} + +message AttackMonster { + uint32 index = 1; +} + +message AttackXY { + sint32 x = 1; + sint32 y = 2; +} + +message OperateObject { + uint32 index = 1; +} + +message UseBeltItem { + uint32 slot = 1; +} + +message ToggleCharacterSheet { + +} + +message IncreaseStat { + uint32 stat = 1; +} + +message GetItem { + uint32 ID = 1; +} + +message SetSpell { + sint32 spellID = 1; + sint32 spellType = 2; +} + +message CastMonster { + uint32 index = 1; +} + +message CastXY { + sint32 x = 1; + sint32 y = 2; +} + +message ToggleInventory { + +} + +message PutInCursor { + uint32 ID = 1; +} + +message PutCursorItem { + sint32 target = 1; +} + +message DropCursorItem { + +} + +message UseItem { + uint32 ID = 1; +} + +message IdentifyStoreItem { + uint32 ID = 1; +} + +message DisarmTrap { + uint32 index = 1; +} + +message SkillRepair { + uint32 ID = 1; +} + +message SkillRecharge { + uint32 ID = 1; +} + +message ToggleMenu { + +} + +message SaveGame { + +} + +message Quit { + +} + +message ClearCursor { + +} + +message IdentifyItem { + uint32 ID = 1; +} + +message Command { + oneof command { + Move move = 1; + Talk talk = 2; + SelectStoreOption option = 3; + BuyItem buyItem = 4; + SellItem sellItem = 5; + RechargeItem rechargeItem = 6; + RepairItem repairItem = 7; + AttackMonster attackMonster = 8; + AttackXY attackXY = 9; + OperateObject operateObject = 10; + UseBeltItem useBeltItem = 11; + ToggleCharacterSheet toggleCharacterSheet = 12; + IncreaseStat increaseStat = 13; + GetItem getItem = 14; + SetSpell setSpell = 15; + CastMonster castMonster = 16; + CastXY castXY = 17; + ToggleInventory toggleInventory = 18; + PutInCursor putInCursor = 19; + PutCursorItem putCursorItem = 20; + DropCursorItem dropCursorItem = 21; + UseItem useItem = 22; + IdentifyStoreItem identifyStoreItem = 23; + CancelQText cancelQText = 24; + SetFPS setFPS = 25; + DisarmTrap disarmTrap = 26; + SkillRepair skillRepair = 27; + SkillRecharge skillRecharge = 28; + ToggleMenu toggleMenu = 29; + SaveGame saveGame = 30; + Quit quit = 31; + ClearCursor clearCursor = 32; + IdentifyItem identifyItem = 33; + } +} diff --git a/Source/dapi/Backend/Messages/data.proto b/Source/dapi/Backend/Messages/data.proto new file mode 100644 index 000000000..ed8876a3e --- /dev/null +++ b/Source/dapi/Backend/Messages/data.proto @@ -0,0 +1,178 @@ +syntax = "proto3"; +option optimize_for = LITE_RUNTIME; + +package dapi.data; + +message QuestData { + uint32 id = 1; + uint32 state = 2; +} + +message PortalData { + uint32 x = 1; + uint32 y = 2; + uint32 player = 3; +} + +message MissileData { + sint32 type = 1; + uint32 x = 2; + uint32 y = 3; + sint32 xvel = 4; + sint32 yvel = 5; + sint32 sx = 6; + sint32 sy = 7; +} + +message ObjectData { + uint32 x = 1; + uint32 y = 2; + sint32 type = 3; + sint32 shrineType = 4; + bool solid = 5; + sint32 doorState = 6; + bool selectable = 7; + uint32 index = 8; + bool trapped = 9; +} + +message MonsterData { + uint32 index = 1; + sint32 x = 2; + sint32 y = 3; + sint32 futx = 4; + sint32 futy = 5; + string name = 6; + sint32 type = 7; + sint32 kills = 8; + sint32 mode = 9; + bool unique = 10; +} + +message TriggerData { + uint32 lvl = 1; + sint32 x = 2; + sint32 y = 3; + sint32 type = 4; +} + +message TileData { + sint32 type = 1; + bool solid = 2; + sint32 x = 3; + sint32 y = 4; + bool stopMissile = 5; +} + +message TownerData { + uint32 ID = 1; + uint32 _ttype = 2; + sint32 _tx = 3; + sint32 _ty = 4; + string _tName = 5; +} + +message ItemData { + uint32 ID = 1; + sint32 _itype = 2; + sint32 _ix = 3; + sint32 _iy = 4; + + bool _iIdentified = 5; + uint32 _iMagical = 6; + string _iName = 7; + string _iIName = 8; + uint32 _iClass = 9; + sint32 _iCurs = 10; + sint32 _iValue = 11; + sint32 _iMinDam = 12; + sint32 _iMaxDam = 13; + sint32 _iAC = 14; + sint32 _iFlags = 15; + sint32 _iMiscId = 16; + sint32 _iSpell = 17; + sint32 _iCharges = 18; + sint32 _iMaxCharges = 19; + sint32 _iDurability = 20; + sint32 _iMaxDur = 21; + sint32 _iPLDam = 22; + sint32 _iPLToHit = 23; + sint32 _iPLAC = 24; + sint32 _iPLStr = 25; + sint32 _iPLMag = 26; + sint32 _iPLDex = 27; + sint32 _iPLVit = 28; + sint32 _iPLFR = 29; + sint32 _iPLLR = 30; + sint32 _iPLMR = 31; + sint32 _iPLMana = 32; + sint32 _iPLHP = 33; + sint32 _iPLDamMod = 34; + sint32 _iPLGetHit = 35; + sint32 _iPLLight = 36; + sint32 _iSplLvlAdd = 37; + sint32 _iFMinDam = 38; + sint32 _iFMaxDam = 39; + sint32 _iLMinDam = 40; + sint32 _iLMaxDam = 41; + sint32 _iPrePower = 42; + sint32 _iSufPower = 43; + sint32 _iMinStr = 44; + sint32 _iMinMag = 45; + sint32 _iMinDex = 46; + bool _iStatFlag = 47; + sint32 IDidx = 48; +} + +message PlayerData { + sint32 _pmode = 1; + sint32 pnum = 2; + sint32 plrlevel = 3; + sint32 _px = 4; + sint32 _py = 5; + sint32 _pfutx = 6; + sint32 _pfuty = 7; + sint32 _pdir = 8; + sint32 _pRSpell = 9; + uint32 _pRsplType = 10; + repeated uint32 _pSplLvl = 11; + uint64 _pMemSpells = 12; + uint64 _pAblSpells = 13; + uint64 _pScrlSpells = 14; + string _pName = 15; + uint32 _pClass = 16; + uint32 _pStrength = 17; + uint32 _pBaseStr = 18; + uint32 _pMagic = 19; + uint32 _pBaseMag = 20; + uint32 _pDexterity = 21; + uint32 _pBaseDex = 22; + uint32 _pVitality = 23; + uint32 _pBaseVit = 24; + uint32 _pStatPts = 25; + uint32 _pDamageMod = 26; + uint32 _pHitPoints = 27; + uint32 _pMaxHP = 28; + sint32 _pMana = 29; + uint32 _pMaxMana = 30; + uint32 _pLevel = 31; + uint32 _pExperience = 32; + uint32 _pArmorClass = 33; + uint32 _pMagResist = 34; + uint32 _pFireResist = 35; + uint32 _pLightResist = 36; + uint32 _pGold = 37; + repeated sint32 InvBody = 38; + repeated sint32 InvList = 39; + repeated sint32 InvGrid = 40; + repeated sint32 SpdList = 41; + sint32 HoldItem = 42; + uint32 _pIAC = 43; + uint32 _pIMinDam = 44; + uint32 _pIMaxDam = 45; + uint32 _pIBonusDam = 46; + uint32 _pIBonusToHit = 47; + uint32 _pIBonusAC = 48; + uint32 _pIBonusDamMod = 49; + bool pManaShield = 50; +} diff --git a/Source/dapi/Backend/Messages/game.proto b/Source/dapi/Backend/Messages/game.proto new file mode 100644 index 000000000..a42630d28 --- /dev/null +++ b/Source/dapi/Backend/Messages/game.proto @@ -0,0 +1,36 @@ +syntax = "proto3"; +option optimize_for = LITE_RUNTIME; +import "data.proto"; + +package dapi.game; + +message FrameUpdate { + uint32 player = 1; + sint32 stextflag = 2; + sint32 pauseMode = 3; + bool menuOpen = 4; + uint32 cursor = 5; + bool chrflag = 6; + bool invflag = 7; + bool qtextflag = 8; + string qtext = 9; + uint32 currlevel = 10; + bool setlevel = 11; + uint32 fps = 12; + uint32 gameMode = 13; + uint32 gnDifficulty = 14; + + repeated dapi.data.TileData dPiece = 15; + repeated dapi.data.PlayerData playerData = 16; + repeated dapi.data.ItemData itemData = 17; + repeated uint32 groundItemID = 18; + repeated dapi.data.TownerData townerData = 19; + repeated uint32 storeOption = 20; + repeated uint32 storeItems = 21; + repeated dapi.data.TriggerData triggerData = 22; + repeated dapi.data.MonsterData monsterData = 23; + repeated dapi.data.ObjectData objectData = 24; + repeated dapi.data.MissileData missileData = 25; + repeated dapi.data.PortalData portalData = 26; + repeated dapi.data.QuestData questData = 27; +} diff --git a/Source/dapi/Backend/Messages/generated/command.pb.cc b/Source/dapi/Backend/Messages/generated/command.pb.cc new file mode 100644 index 000000000..9b8c1c07e --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/command.pb.cc @@ -0,0 +1,9501 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: command.proto +// Protobuf C++ Version: 5.29.3 + +#include "command.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace dapi { +namespace commands { + +inline constexpr UseItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR UseItem::UseItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct UseItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseItemDefaultTypeInternal() {} + union { + UseItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseItemDefaultTypeInternal _UseItem_default_instance_; + +inline constexpr UseBeltItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : slot_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR UseBeltItem::UseBeltItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct UseBeltItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR UseBeltItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~UseBeltItemDefaultTypeInternal() {} + union { + UseBeltItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseBeltItemDefaultTypeInternal _UseBeltItem_default_instance_; + +inline constexpr ToggleMenu::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ToggleMenu::ToggleMenu(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ToggleMenuDefaultTypeInternal { + PROTOBUF_CONSTEXPR ToggleMenuDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ToggleMenuDefaultTypeInternal() {} + union { + ToggleMenu _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleMenuDefaultTypeInternal _ToggleMenu_default_instance_; + +inline constexpr ToggleInventory::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ToggleInventory::ToggleInventory(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ToggleInventoryDefaultTypeInternal { + PROTOBUF_CONSTEXPR ToggleInventoryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ToggleInventoryDefaultTypeInternal() {} + union { + ToggleInventory _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleInventoryDefaultTypeInternal _ToggleInventory_default_instance_; + +inline constexpr ToggleCharacterSheet::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ToggleCharacterSheet::ToggleCharacterSheet(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ToggleCharacterSheetDefaultTypeInternal { + PROTOBUF_CONSTEXPR ToggleCharacterSheetDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ToggleCharacterSheetDefaultTypeInternal() {} + union { + ToggleCharacterSheet _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleCharacterSheetDefaultTypeInternal _ToggleCharacterSheet_default_instance_; + +inline constexpr Talk::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : targetx_{0u}, + targety_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Talk::Talk(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct TalkDefaultTypeInternal { + PROTOBUF_CONSTEXPR TalkDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TalkDefaultTypeInternal() {} + union { + Talk _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TalkDefaultTypeInternal _Talk_default_instance_; + +inline constexpr SkillRepair::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SkillRepair::SkillRepair(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SkillRepairDefaultTypeInternal { + PROTOBUF_CONSTEXPR SkillRepairDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SkillRepairDefaultTypeInternal() {} + union { + SkillRepair _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillRepairDefaultTypeInternal _SkillRepair_default_instance_; + +inline constexpr SkillRecharge::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SkillRecharge::SkillRecharge(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SkillRechargeDefaultTypeInternal { + PROTOBUF_CONSTEXPR SkillRechargeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SkillRechargeDefaultTypeInternal() {} + union { + SkillRecharge _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillRechargeDefaultTypeInternal _SkillRecharge_default_instance_; + +inline constexpr SetSpell::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : spellid_{0}, + spelltype_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetSpell::SetSpell(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetSpellDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetSpellDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetSpellDefaultTypeInternal() {} + union { + SetSpell _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetSpellDefaultTypeInternal _SetSpell_default_instance_; + +inline constexpr SetFPS::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : fps_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SetFPS::SetFPS(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SetFPSDefaultTypeInternal { + PROTOBUF_CONSTEXPR SetFPSDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SetFPSDefaultTypeInternal() {} + union { + SetFPS _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFPSDefaultTypeInternal _SetFPS_default_instance_; + +inline constexpr SellItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SellItem::SellItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SellItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR SellItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SellItemDefaultTypeInternal() {} + union { + SellItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SellItemDefaultTypeInternal _SellItem_default_instance_; + +inline constexpr SelectStoreOption::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : option_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SelectStoreOption::SelectStoreOption(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SelectStoreOptionDefaultTypeInternal { + PROTOBUF_CONSTEXPR SelectStoreOptionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SelectStoreOptionDefaultTypeInternal() {} + union { + SelectStoreOption _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SelectStoreOptionDefaultTypeInternal _SelectStoreOption_default_instance_; + +inline constexpr SaveGame::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR SaveGame::SaveGame(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct SaveGameDefaultTypeInternal { + PROTOBUF_CONSTEXPR SaveGameDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~SaveGameDefaultTypeInternal() {} + union { + SaveGame _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveGameDefaultTypeInternal _SaveGame_default_instance_; + +inline constexpr RepairItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RepairItem::RepairItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RepairItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR RepairItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RepairItemDefaultTypeInternal() {} + union { + RepairItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RepairItemDefaultTypeInternal _RepairItem_default_instance_; + +inline constexpr RechargeItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR RechargeItem::RechargeItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct RechargeItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR RechargeItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~RechargeItemDefaultTypeInternal() {} + union { + RechargeItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RechargeItemDefaultTypeInternal _RechargeItem_default_instance_; + +inline constexpr Quit::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Quit::Quit(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct QuitDefaultTypeInternal { + PROTOBUF_CONSTEXPR QuitDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~QuitDefaultTypeInternal() {} + union { + Quit _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QuitDefaultTypeInternal _Quit_default_instance_; + +inline constexpr PutInCursor::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR PutInCursor::PutInCursor(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct PutInCursorDefaultTypeInternal { + PROTOBUF_CONSTEXPR PutInCursorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PutInCursorDefaultTypeInternal() {} + union { + PutInCursor _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutInCursorDefaultTypeInternal _PutInCursor_default_instance_; + +inline constexpr PutCursorItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : target_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR PutCursorItem::PutCursorItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct PutCursorItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR PutCursorItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PutCursorItemDefaultTypeInternal() {} + union { + PutCursorItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutCursorItemDefaultTypeInternal _PutCursorItem_default_instance_; + +inline constexpr OperateObject::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR OperateObject::OperateObject(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct OperateObjectDefaultTypeInternal { + PROTOBUF_CONSTEXPR OperateObjectDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~OperateObjectDefaultTypeInternal() {} + union { + OperateObject _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperateObjectDefaultTypeInternal _OperateObject_default_instance_; + +inline constexpr Move::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : type_{0u}, + targetx_{0u}, + targety_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR Move::Move(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct MoveDefaultTypeInternal { + PROTOBUF_CONSTEXPR MoveDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~MoveDefaultTypeInternal() {} + union { + Move _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoveDefaultTypeInternal _Move_default_instance_; + +inline constexpr IncreaseStat::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : stat_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR IncreaseStat::IncreaseStat(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct IncreaseStatDefaultTypeInternal { + PROTOBUF_CONSTEXPR IncreaseStatDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IncreaseStatDefaultTypeInternal() {} + union { + IncreaseStat _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IncreaseStatDefaultTypeInternal _IncreaseStat_default_instance_; + +inline constexpr IdentifyStoreItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR IdentifyStoreItem::IdentifyStoreItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct IdentifyStoreItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR IdentifyStoreItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IdentifyStoreItemDefaultTypeInternal() {} + union { + IdentifyStoreItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentifyStoreItemDefaultTypeInternal _IdentifyStoreItem_default_instance_; + +inline constexpr IdentifyItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR IdentifyItem::IdentifyItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct IdentifyItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR IdentifyItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~IdentifyItemDefaultTypeInternal() {} + union { + IdentifyItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentifyItemDefaultTypeInternal _IdentifyItem_default_instance_; + +inline constexpr GetItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR GetItem::GetItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct GetItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR GetItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~GetItemDefaultTypeInternal() {} + union { + GetItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetItemDefaultTypeInternal _GetItem_default_instance_; + +inline constexpr DropCursorItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR DropCursorItem::DropCursorItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct DropCursorItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR DropCursorItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~DropCursorItemDefaultTypeInternal() {} + union { + DropCursorItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DropCursorItemDefaultTypeInternal _DropCursorItem_default_instance_; + +inline constexpr DisarmTrap::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR DisarmTrap::DisarmTrap(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct DisarmTrapDefaultTypeInternal { + PROTOBUF_CONSTEXPR DisarmTrapDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~DisarmTrapDefaultTypeInternal() {} + union { + DisarmTrap _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DisarmTrapDefaultTypeInternal _DisarmTrap_default_instance_; + +inline constexpr ClearCursor::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ClearCursor::ClearCursor(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ClearCursorDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClearCursorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClearCursorDefaultTypeInternal() {} + union { + ClearCursor _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClearCursorDefaultTypeInternal _ClearCursor_default_instance_; + +inline constexpr CastXY::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : x_{0}, + y_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CastXY::CastXY(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CastXYDefaultTypeInternal { + PROTOBUF_CONSTEXPR CastXYDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CastXYDefaultTypeInternal() {} + union { + CastXY _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CastXYDefaultTypeInternal _CastXY_default_instance_; + +inline constexpr CastMonster::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CastMonster::CastMonster(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CastMonsterDefaultTypeInternal { + PROTOBUF_CONSTEXPR CastMonsterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CastMonsterDefaultTypeInternal() {} + union { + CastMonster _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CastMonsterDefaultTypeInternal _CastMonster_default_instance_; + +inline constexpr CancelQText::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR CancelQText::CancelQText(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CancelQTextDefaultTypeInternal { + PROTOBUF_CONSTEXPR CancelQTextDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CancelQTextDefaultTypeInternal() {} + union { + CancelQText _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CancelQTextDefaultTypeInternal _CancelQText_default_instance_; + +inline constexpr BuyItem::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR BuyItem::BuyItem(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct BuyItemDefaultTypeInternal { + PROTOBUF_CONSTEXPR BuyItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~BuyItemDefaultTypeInternal() {} + union { + BuyItem _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BuyItemDefaultTypeInternal _BuyItem_default_instance_; + +inline constexpr AttackXY::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : x_{0}, + y_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR AttackXY::AttackXY(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct AttackXYDefaultTypeInternal { + PROTOBUF_CONSTEXPR AttackXYDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~AttackXYDefaultTypeInternal() {} + union { + AttackXY _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackXYDefaultTypeInternal _AttackXY_default_instance_; + +inline constexpr AttackMonster::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR AttackMonster::AttackMonster(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct AttackMonsterDefaultTypeInternal { + PROTOBUF_CONSTEXPR AttackMonsterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~AttackMonsterDefaultTypeInternal() {} + union { + AttackMonster _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackMonsterDefaultTypeInternal _AttackMonster_default_instance_; + +inline constexpr Command::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : command_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Command::Command(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct CommandDefaultTypeInternal { + PROTOBUF_CONSTEXPR CommandDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~CommandDefaultTypeInternal() {} + union { + Command _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommandDefaultTypeInternal _Command_default_instance_; +} // namespace commands +} // namespace dapi +namespace dapi { +namespace commands { +// =================================================================== + +class SetFPS::_Internal { + public: +}; + +SetFPS::SetFPS(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SetFPS) +} +SetFPS::SetFPS( + ::google::protobuf::Arena* arena, const SetFPS& from) + : SetFPS(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SetFPS::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetFPS::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.fps_ = {}; +} +SetFPS::~SetFPS() { + // @@protoc_insertion_point(destructor:dapi.commands.SetFPS) + SharedDtor(*this); +} +inline void SetFPS::SharedDtor(MessageLite& self) { + SetFPS& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SetFPS::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetFPS(arena); +} +constexpr auto SetFPS::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFPS), + alignof(SetFPS)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> SetFPS::_class_data_ = { + { + &_SetFPS_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetFPS::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetFPS::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SetFPS::ByteSizeLong, + &SetFPS::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetFPS, _impl_._cached_size_), + true, + }, + "dapi.commands.SetFPS", +}; +const ::google::protobuf::internal::ClassData* SetFPS::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SetFPS::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SetFPS>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 FPS = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetFPS, _impl_.fps_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 FPS = 1; + {PROTOBUF_FIELD_OFFSET(SetFPS, _impl_.fps_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SetFPS::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SetFPS) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.fps_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetFPS::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetFPS& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetFPS::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetFPS& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SetFPS) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 FPS = 1; + if (this_._internal_fps() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_fps(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SetFPS) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetFPS::ByteSizeLong(const MessageLite& base) { + const SetFPS& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetFPS::ByteSizeLong() const { + const SetFPS& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SetFPS) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 FPS = 1; + if (this_._internal_fps() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_fps()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SetFPS::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SetFPS) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_fps() != 0) { + _this->_impl_.fps_ = from._impl_.fps_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SetFPS::CopyFrom(const SetFPS& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SetFPS) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetFPS::InternalSwap(SetFPS* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.fps_, other->_impl_.fps_); +} + +// =================================================================== + +class CancelQText::_Internal { + public: +}; + +CancelQText::CancelQText(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.CancelQText) +} +CancelQText::CancelQText( + ::google::protobuf::Arena* arena, const CancelQText& from) + : CancelQText(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE CancelQText::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void CancelQText::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +CancelQText::~CancelQText() { + // @@protoc_insertion_point(destructor:dapi.commands.CancelQText) + SharedDtor(*this); +} +inline void CancelQText::SharedDtor(MessageLite& self) { + CancelQText& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* CancelQText::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CancelQText(arena); +} +constexpr auto CancelQText::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CancelQText), + alignof(CancelQText)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> CancelQText::_class_data_ = { + { + &_CancelQText_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CancelQText::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CancelQText::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &CancelQText::ByteSizeLong, + &CancelQText::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CancelQText, _impl_._cached_size_), + true, + }, + "dapi.commands.CancelQText", +}; +const ::google::protobuf::internal::ClassData* CancelQText::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> CancelQText::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::CancelQText>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void CancelQText::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.CancelQText) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CancelQText::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CancelQText& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CancelQText::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CancelQText& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CancelQText) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CancelQText) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CancelQText::ByteSizeLong(const MessageLite& base) { + const CancelQText& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CancelQText::ByteSizeLong() const { + const CancelQText& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CancelQText) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void CancelQText::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CancelQText) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void CancelQText::CopyFrom(const CancelQText& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CancelQText) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CancelQText::InternalSwap(CancelQText* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class Move::_Internal { + public: +}; + +Move::Move(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.Move) +} +Move::Move( + ::google::protobuf::Arena* arena, const Move& from) + : Move(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE Move::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void Move::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, type_), + 0, + offsetof(Impl_, targety_) - + offsetof(Impl_, type_) + + sizeof(Impl_::targety_)); +} +Move::~Move() { + // @@protoc_insertion_point(destructor:dapi.commands.Move) + SharedDtor(*this); +} +inline void Move::SharedDtor(MessageLite& self) { + Move& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* Move::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Move(arena); +} +constexpr auto Move::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Move), + alignof(Move)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<19> Move::_class_data_ = { + { + &_Move_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Move::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Move::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &Move::ByteSizeLong, + &Move::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Move, _impl_._cached_size_), + true, + }, + "dapi.commands.Move", +}; +const ::google::protobuf::internal::ClassData* Move::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 0, 2> Move::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::Move>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 type = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.type_)}}, + // uint32 targetX = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.targetx_)}}, + // uint32 targetY = 3; + {::_pbi::TcParser::FastV32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 type = 1; + {PROTOBUF_FIELD_OFFSET(Move, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 targetX = 2; + {PROTOBUF_FIELD_OFFSET(Move, _impl_.targetx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 targetY = 3; + {PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void Move::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.Move) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.type_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.targety_) - + reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.targety_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Move::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Move& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Move::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Move& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Move) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 type = 1; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_type(), target); + } + + // uint32 targetX = 2; + if (this_._internal_targetx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_targetx(), target); + } + + // uint32 targetY = 3; + if (this_._internal_targety() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_targety(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Move) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Move::ByteSizeLong(const MessageLite& base) { + const Move& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Move::ByteSizeLong() const { + const Move& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Move) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 type = 1; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_type()); + } + // uint32 targetX = 2; + if (this_._internal_targetx() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_targetx()); + } + // uint32 targetY = 3; + if (this_._internal_targety() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_targety()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void Move::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Move) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + if (from._internal_targetx() != 0) { + _this->_impl_.targetx_ = from._impl_.targetx_; + } + if (from._internal_targety() != 0) { + _this->_impl_.targety_ = from._impl_.targety_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void Move::CopyFrom(const Move& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Move) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Move::InternalSwap(Move* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_) + + sizeof(Move::_impl_.targety_) + - PROTOBUF_FIELD_OFFSET(Move, _impl_.type_)>( + reinterpret_cast(&_impl_.type_), + reinterpret_cast(&other->_impl_.type_)); +} + +// =================================================================== + +class Talk::_Internal { + public: +}; + +Talk::Talk(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.Talk) +} +Talk::Talk( + ::google::protobuf::Arena* arena, const Talk& from) + : Talk(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE Talk::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void Talk::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, targetx_), + 0, + offsetof(Impl_, targety_) - + offsetof(Impl_, targetx_) + + sizeof(Impl_::targety_)); +} +Talk::~Talk() { + // @@protoc_insertion_point(destructor:dapi.commands.Talk) + SharedDtor(*this); +} +inline void Talk::SharedDtor(MessageLite& self) { + Talk& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* Talk::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Talk(arena); +} +constexpr auto Talk::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Talk), + alignof(Talk)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<19> Talk::_class_data_ = { + { + &_Talk_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Talk::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Talk::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &Talk::ByteSizeLong, + &Talk::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Talk, _impl_._cached_size_), + true, + }, + "dapi.commands.Talk", +}; +const ::google::protobuf::internal::ClassData* Talk::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> Talk::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::Talk>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 targetY = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_)}}, + // uint32 targetX = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 targetX = 1; + {PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 targetY = 2; + {PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void Talk::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.Talk) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.targetx_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.targety_) - + reinterpret_cast(&_impl_.targetx_)) + sizeof(_impl_.targety_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Talk::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Talk& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Talk::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Talk& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Talk) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 targetX = 1; + if (this_._internal_targetx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_targetx(), target); + } + + // uint32 targetY = 2; + if (this_._internal_targety() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_targety(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Talk) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Talk::ByteSizeLong(const MessageLite& base) { + const Talk& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Talk::ByteSizeLong() const { + const Talk& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Talk) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 targetX = 1; + if (this_._internal_targetx() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_targetx()); + } + // uint32 targetY = 2; + if (this_._internal_targety() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_targety()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void Talk::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Talk) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_targetx() != 0) { + _this->_impl_.targetx_ = from._impl_.targetx_; + } + if (from._internal_targety() != 0) { + _this->_impl_.targety_ = from._impl_.targety_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void Talk::CopyFrom(const Talk& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Talk) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Talk::InternalSwap(Talk* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_) + + sizeof(Talk::_impl_.targety_) + - PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_)>( + reinterpret_cast(&_impl_.targetx_), + reinterpret_cast(&other->_impl_.targetx_)); +} + +// =================================================================== + +class SelectStoreOption::_Internal { + public: +}; + +SelectStoreOption::SelectStoreOption(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SelectStoreOption) +} +SelectStoreOption::SelectStoreOption( + ::google::protobuf::Arena* arena, const SelectStoreOption& from) + : SelectStoreOption(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SelectStoreOption::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SelectStoreOption::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.option_ = {}; +} +SelectStoreOption::~SelectStoreOption() { + // @@protoc_insertion_point(destructor:dapi.commands.SelectStoreOption) + SharedDtor(*this); +} +inline void SelectStoreOption::SharedDtor(MessageLite& self) { + SelectStoreOption& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SelectStoreOption::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SelectStoreOption(arena); +} +constexpr auto SelectStoreOption::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SelectStoreOption), + alignof(SelectStoreOption)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<32> SelectStoreOption::_class_data_ = { + { + &_SelectStoreOption_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SelectStoreOption::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SelectStoreOption::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SelectStoreOption::ByteSizeLong, + &SelectStoreOption::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_._cached_size_), + true, + }, + "dapi.commands.SelectStoreOption", +}; +const ::google::protobuf::internal::ClassData* SelectStoreOption::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SelectStoreOption::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SelectStoreOption>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 option = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_.option_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 option = 1; + {PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_.option_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SelectStoreOption::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SelectStoreOption) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.option_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SelectStoreOption::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SelectStoreOption& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SelectStoreOption::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SelectStoreOption& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SelectStoreOption) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 option = 1; + if (this_._internal_option() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_option(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SelectStoreOption) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SelectStoreOption::ByteSizeLong(const MessageLite& base) { + const SelectStoreOption& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SelectStoreOption::ByteSizeLong() const { + const SelectStoreOption& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SelectStoreOption) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 option = 1; + if (this_._internal_option() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_option()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SelectStoreOption::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SelectStoreOption) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_option() != 0) { + _this->_impl_.option_ = from._impl_.option_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SelectStoreOption::CopyFrom(const SelectStoreOption& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SelectStoreOption) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SelectStoreOption::InternalSwap(SelectStoreOption* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.option_, other->_impl_.option_); +} + +// =================================================================== + +class BuyItem::_Internal { + public: +}; + +BuyItem::BuyItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.BuyItem) +} +BuyItem::BuyItem( + ::google::protobuf::Arena* arena, const BuyItem& from) + : BuyItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE BuyItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void BuyItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +BuyItem::~BuyItem() { + // @@protoc_insertion_point(destructor:dapi.commands.BuyItem) + SharedDtor(*this); +} +inline void BuyItem::SharedDtor(MessageLite& self) { + BuyItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* BuyItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) BuyItem(arena); +} +constexpr auto BuyItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BuyItem), + alignof(BuyItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> BuyItem::_class_data_ = { + { + &_BuyItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &BuyItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &BuyItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &BuyItem::ByteSizeLong, + &BuyItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(BuyItem, _impl_._cached_size_), + true, + }, + "dapi.commands.BuyItem", +}; +const ::google::protobuf::internal::ClassData* BuyItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> BuyItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::BuyItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(BuyItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(BuyItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void BuyItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.BuyItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* BuyItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const BuyItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* BuyItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const BuyItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.BuyItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.BuyItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t BuyItem::ByteSizeLong(const MessageLite& base) { + const BuyItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t BuyItem::ByteSizeLong() const { + const BuyItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.BuyItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void BuyItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.BuyItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void BuyItem::CopyFrom(const BuyItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.BuyItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void BuyItem::InternalSwap(BuyItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class SellItem::_Internal { + public: +}; + +SellItem::SellItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SellItem) +} +SellItem::SellItem( + ::google::protobuf::Arena* arena, const SellItem& from) + : SellItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SellItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SellItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +SellItem::~SellItem() { + // @@protoc_insertion_point(destructor:dapi.commands.SellItem) + SharedDtor(*this); +} +inline void SellItem::SharedDtor(MessageLite& self) { + SellItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SellItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SellItem(arena); +} +constexpr auto SellItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SellItem), + alignof(SellItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<23> SellItem::_class_data_ = { + { + &_SellItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SellItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SellItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SellItem::ByteSizeLong, + &SellItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SellItem, _impl_._cached_size_), + true, + }, + "dapi.commands.SellItem", +}; +const ::google::protobuf::internal::ClassData* SellItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SellItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SellItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SellItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(SellItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SellItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SellItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SellItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SellItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SellItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SellItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SellItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SellItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SellItem::ByteSizeLong(const MessageLite& base) { + const SellItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SellItem::ByteSizeLong() const { + const SellItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SellItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SellItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SellItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SellItem::CopyFrom(const SellItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SellItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SellItem::InternalSwap(SellItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class RechargeItem::_Internal { + public: +}; + +RechargeItem::RechargeItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.RechargeItem) +} +RechargeItem::RechargeItem( + ::google::protobuf::Arena* arena, const RechargeItem& from) + : RechargeItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE RechargeItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RechargeItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +RechargeItem::~RechargeItem() { + // @@protoc_insertion_point(destructor:dapi.commands.RechargeItem) + SharedDtor(*this); +} +inline void RechargeItem::SharedDtor(MessageLite& self) { + RechargeItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RechargeItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RechargeItem(arena); +} +constexpr auto RechargeItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RechargeItem), + alignof(RechargeItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<27> RechargeItem::_class_data_ = { + { + &_RechargeItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RechargeItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RechargeItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &RechargeItem::ByteSizeLong, + &RechargeItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_._cached_size_), + true, + }, + "dapi.commands.RechargeItem", +}; +const ::google::protobuf::internal::ClassData* RechargeItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RechargeItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::RechargeItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RechargeItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.RechargeItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RechargeItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RechargeItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RechargeItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RechargeItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.RechargeItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.RechargeItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RechargeItem::ByteSizeLong(const MessageLite& base) { + const RechargeItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RechargeItem::ByteSizeLong() const { + const RechargeItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.RechargeItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void RechargeItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.RechargeItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void RechargeItem::CopyFrom(const RechargeItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.RechargeItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RechargeItem::InternalSwap(RechargeItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class RepairItem::_Internal { + public: +}; + +RepairItem::RepairItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.RepairItem) +} +RepairItem::RepairItem( + ::google::protobuf::Arena* arena, const RepairItem& from) + : RepairItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE RepairItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void RepairItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +RepairItem::~RepairItem() { + // @@protoc_insertion_point(destructor:dapi.commands.RepairItem) + SharedDtor(*this); +} +inline void RepairItem::SharedDtor(MessageLite& self) { + RepairItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* RepairItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) RepairItem(arena); +} +constexpr auto RepairItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RepairItem), + alignof(RepairItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<25> RepairItem::_class_data_ = { + { + &_RepairItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &RepairItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &RepairItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &RepairItem::ByteSizeLong, + &RepairItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(RepairItem, _impl_._cached_size_), + true, + }, + "dapi.commands.RepairItem", +}; +const ::google::protobuf::internal::ClassData* RepairItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RepairItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::RepairItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(RepairItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(RepairItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void RepairItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.RepairItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* RepairItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const RepairItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* RepairItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const RepairItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.RepairItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.RepairItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t RepairItem::ByteSizeLong(const MessageLite& base) { + const RepairItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t RepairItem::ByteSizeLong() const { + const RepairItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.RepairItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void RepairItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.RepairItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void RepairItem::CopyFrom(const RepairItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.RepairItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void RepairItem::InternalSwap(RepairItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class AttackMonster::_Internal { + public: +}; + +AttackMonster::AttackMonster(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.AttackMonster) +} +AttackMonster::AttackMonster( + ::google::protobuf::Arena* arena, const AttackMonster& from) + : AttackMonster(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE AttackMonster::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void AttackMonster::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.index_ = {}; +} +AttackMonster::~AttackMonster() { + // @@protoc_insertion_point(destructor:dapi.commands.AttackMonster) + SharedDtor(*this); +} +inline void AttackMonster::SharedDtor(MessageLite& self) { + AttackMonster& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* AttackMonster::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) AttackMonster(arena); +} +constexpr auto AttackMonster::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AttackMonster), + alignof(AttackMonster)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<28> AttackMonster::_class_data_ = { + { + &_AttackMonster_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AttackMonster::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AttackMonster::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &AttackMonster::ByteSizeLong, + &AttackMonster::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_._cached_size_), + true, + }, + "dapi.commands.AttackMonster", +}; +const ::google::protobuf::internal::ClassData* AttackMonster::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> AttackMonster::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::AttackMonster>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 index = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_.index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 index = 1; + {PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void AttackMonster::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.AttackMonster) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* AttackMonster::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const AttackMonster& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* AttackMonster::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const AttackMonster& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.AttackMonster) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 index = 1; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.AttackMonster) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t AttackMonster::ByteSizeLong(const MessageLite& base) { + const AttackMonster& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t AttackMonster::ByteSizeLong() const { + const AttackMonster& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.AttackMonster) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 index = 1; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void AttackMonster::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.AttackMonster) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AttackMonster::CopyFrom(const AttackMonster& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.AttackMonster) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AttackMonster::InternalSwap(AttackMonster* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.index_, other->_impl_.index_); +} + +// =================================================================== + +class AttackXY::_Internal { + public: +}; + +AttackXY::AttackXY(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.AttackXY) +} +AttackXY::AttackXY( + ::google::protobuf::Arena* arena, const AttackXY& from) + : AttackXY(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE AttackXY::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void AttackXY::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, x_), + 0, + offsetof(Impl_, y_) - + offsetof(Impl_, x_) + + sizeof(Impl_::y_)); +} +AttackXY::~AttackXY() { + // @@protoc_insertion_point(destructor:dapi.commands.AttackXY) + SharedDtor(*this); +} +inline void AttackXY::SharedDtor(MessageLite& self) { + AttackXY& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* AttackXY::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) AttackXY(arena); +} +constexpr auto AttackXY::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AttackXY), + alignof(AttackXY)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<23> AttackXY::_class_data_ = { + { + &_AttackXY_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &AttackXY::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &AttackXY::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &AttackXY::ByteSizeLong, + &AttackXY::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(AttackXY, _impl_._cached_size_), + true, + }, + "dapi.commands.AttackXY", +}; +const ::google::protobuf::internal::ClassData* AttackXY::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> AttackXY::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::AttackXY>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // sint32 y = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_)}}, + // sint32 x = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 x = 1; + {PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 y = 2; + {PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void AttackXY::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.AttackXY) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.y_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.y_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* AttackXY::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const AttackXY& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* AttackXY::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const AttackXY& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.AttackXY) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 x = 1; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_x(), target); + } + + // sint32 y = 2; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_y(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.AttackXY) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t AttackXY::ByteSizeLong(const MessageLite& base) { + const AttackXY& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t AttackXY::ByteSizeLong() const { + const AttackXY& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.AttackXY) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // sint32 x = 1; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_x()); + } + // sint32 y = 2; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_y()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void AttackXY::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.AttackXY) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void AttackXY::CopyFrom(const AttackXY& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.AttackXY) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void AttackXY::InternalSwap(AttackXY* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_) + + sizeof(AttackXY::_impl_.y_) + - PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +// =================================================================== + +class OperateObject::_Internal { + public: +}; + +OperateObject::OperateObject(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.OperateObject) +} +OperateObject::OperateObject( + ::google::protobuf::Arena* arena, const OperateObject& from) + : OperateObject(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE OperateObject::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void OperateObject::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.index_ = {}; +} +OperateObject::~OperateObject() { + // @@protoc_insertion_point(destructor:dapi.commands.OperateObject) + SharedDtor(*this); +} +inline void OperateObject::SharedDtor(MessageLite& self) { + OperateObject& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* OperateObject::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) OperateObject(arena); +} +constexpr auto OperateObject::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(OperateObject), + alignof(OperateObject)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<28> OperateObject::_class_data_ = { + { + &_OperateObject_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &OperateObject::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &OperateObject::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &OperateObject::ByteSizeLong, + &OperateObject::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(OperateObject, _impl_._cached_size_), + true, + }, + "dapi.commands.OperateObject", +}; +const ::google::protobuf::internal::ClassData* OperateObject::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OperateObject::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::OperateObject>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 index = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(OperateObject, _impl_.index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 index = 1; + {PROTOBUF_FIELD_OFFSET(OperateObject, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void OperateObject::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.OperateObject) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* OperateObject::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const OperateObject& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* OperateObject::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const OperateObject& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.OperateObject) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 index = 1; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.OperateObject) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t OperateObject::ByteSizeLong(const MessageLite& base) { + const OperateObject& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t OperateObject::ByteSizeLong() const { + const OperateObject& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.OperateObject) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 index = 1; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void OperateObject::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.OperateObject) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void OperateObject::CopyFrom(const OperateObject& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.OperateObject) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void OperateObject::InternalSwap(OperateObject* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.index_, other->_impl_.index_); +} + +// =================================================================== + +class UseBeltItem::_Internal { + public: +}; + +UseBeltItem::UseBeltItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.UseBeltItem) +} +UseBeltItem::UseBeltItem( + ::google::protobuf::Arena* arena, const UseBeltItem& from) + : UseBeltItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE UseBeltItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void UseBeltItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.slot_ = {}; +} +UseBeltItem::~UseBeltItem() { + // @@protoc_insertion_point(destructor:dapi.commands.UseBeltItem) + SharedDtor(*this); +} +inline void UseBeltItem::SharedDtor(MessageLite& self) { + UseBeltItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* UseBeltItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseBeltItem(arena); +} +constexpr auto UseBeltItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseBeltItem), + alignof(UseBeltItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> UseBeltItem::_class_data_ = { + { + &_UseBeltItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseBeltItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseBeltItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &UseBeltItem::ByteSizeLong, + &UseBeltItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_._cached_size_), + true, + }, + "dapi.commands.UseBeltItem", +}; +const ::google::protobuf::internal::ClassData* UseBeltItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> UseBeltItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::UseBeltItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 slot = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_.slot_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 slot = 1; + {PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_.slot_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void UseBeltItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.UseBeltItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.slot_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* UseBeltItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const UseBeltItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* UseBeltItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const UseBeltItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.UseBeltItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 slot = 1; + if (this_._internal_slot() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_slot(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.UseBeltItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t UseBeltItem::ByteSizeLong(const MessageLite& base) { + const UseBeltItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t UseBeltItem::ByteSizeLong() const { + const UseBeltItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.UseBeltItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 slot = 1; + if (this_._internal_slot() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_slot()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void UseBeltItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.UseBeltItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_slot() != 0) { + _this->_impl_.slot_ = from._impl_.slot_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void UseBeltItem::CopyFrom(const UseBeltItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.UseBeltItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void UseBeltItem::InternalSwap(UseBeltItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.slot_, other->_impl_.slot_); +} + +// =================================================================== + +class ToggleCharacterSheet::_Internal { + public: +}; + +ToggleCharacterSheet::ToggleCharacterSheet(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleCharacterSheet) +} +ToggleCharacterSheet::ToggleCharacterSheet( + ::google::protobuf::Arena* arena, const ToggleCharacterSheet& from) + : ToggleCharacterSheet(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ToggleCharacterSheet::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ToggleCharacterSheet::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ToggleCharacterSheet::~ToggleCharacterSheet() { + // @@protoc_insertion_point(destructor:dapi.commands.ToggleCharacterSheet) + SharedDtor(*this); +} +inline void ToggleCharacterSheet::SharedDtor(MessageLite& self) { + ToggleCharacterSheet& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ToggleCharacterSheet::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ToggleCharacterSheet(arena); +} +constexpr auto ToggleCharacterSheet::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleCharacterSheet), + alignof(ToggleCharacterSheet)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<35> ToggleCharacterSheet::_class_data_ = { + { + &_ToggleCharacterSheet_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ToggleCharacterSheet::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ToggleCharacterSheet::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ToggleCharacterSheet::ByteSizeLong, + &ToggleCharacterSheet::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ToggleCharacterSheet, _impl_._cached_size_), + true, + }, + "dapi.commands.ToggleCharacterSheet", +}; +const ::google::protobuf::internal::ClassData* ToggleCharacterSheet::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleCharacterSheet::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::ToggleCharacterSheet>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ToggleCharacterSheet::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleCharacterSheet) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ToggleCharacterSheet::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ToggleCharacterSheet& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ToggleCharacterSheet::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ToggleCharacterSheet& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleCharacterSheet) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleCharacterSheet) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ToggleCharacterSheet::ByteSizeLong(const MessageLite& base) { + const ToggleCharacterSheet& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ToggleCharacterSheet::ByteSizeLong() const { + const ToggleCharacterSheet& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleCharacterSheet) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ToggleCharacterSheet::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleCharacterSheet) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ToggleCharacterSheet::CopyFrom(const ToggleCharacterSheet& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleCharacterSheet) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ToggleCharacterSheet::InternalSwap(ToggleCharacterSheet* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class IncreaseStat::_Internal { + public: +}; + +IncreaseStat::IncreaseStat(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.IncreaseStat) +} +IncreaseStat::IncreaseStat( + ::google::protobuf::Arena* arena, const IncreaseStat& from) + : IncreaseStat(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE IncreaseStat::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void IncreaseStat::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.stat_ = {}; +} +IncreaseStat::~IncreaseStat() { + // @@protoc_insertion_point(destructor:dapi.commands.IncreaseStat) + SharedDtor(*this); +} +inline void IncreaseStat::SharedDtor(MessageLite& self) { + IncreaseStat& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* IncreaseStat::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) IncreaseStat(arena); +} +constexpr auto IncreaseStat::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IncreaseStat), + alignof(IncreaseStat)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<27> IncreaseStat::_class_data_ = { + { + &_IncreaseStat_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IncreaseStat::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IncreaseStat::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &IncreaseStat::ByteSizeLong, + &IncreaseStat::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_._cached_size_), + true, + }, + "dapi.commands.IncreaseStat", +}; +const ::google::protobuf::internal::ClassData* IncreaseStat::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IncreaseStat::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::IncreaseStat>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 stat = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_.stat_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 stat = 1; + {PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_.stat_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void IncreaseStat::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.IncreaseStat) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.stat_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* IncreaseStat::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const IncreaseStat& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* IncreaseStat::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const IncreaseStat& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IncreaseStat) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 stat = 1; + if (this_._internal_stat() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_stat(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IncreaseStat) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t IncreaseStat::ByteSizeLong(const MessageLite& base) { + const IncreaseStat& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t IncreaseStat::ByteSizeLong() const { + const IncreaseStat& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IncreaseStat) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 stat = 1; + if (this_._internal_stat() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_stat()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void IncreaseStat::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IncreaseStat) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_stat() != 0) { + _this->_impl_.stat_ = from._impl_.stat_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void IncreaseStat::CopyFrom(const IncreaseStat& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IncreaseStat) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void IncreaseStat::InternalSwap(IncreaseStat* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.stat_, other->_impl_.stat_); +} + +// =================================================================== + +class GetItem::_Internal { + public: +}; + +GetItem::GetItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.GetItem) +} +GetItem::GetItem( + ::google::protobuf::Arena* arena, const GetItem& from) + : GetItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE GetItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void GetItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +GetItem::~GetItem() { + // @@protoc_insertion_point(destructor:dapi.commands.GetItem) + SharedDtor(*this); +} +inline void GetItem::SharedDtor(MessageLite& self) { + GetItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* GetItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) GetItem(arena); +} +constexpr auto GetItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(GetItem), + alignof(GetItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> GetItem::_class_data_ = { + { + &_GetItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &GetItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &GetItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &GetItem::ByteSizeLong, + &GetItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(GetItem, _impl_._cached_size_), + true, + }, + "dapi.commands.GetItem", +}; +const ::google::protobuf::internal::ClassData* GetItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> GetItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::GetItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(GetItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(GetItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void GetItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.GetItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* GetItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const GetItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* GetItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const GetItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.GetItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.GetItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t GetItem::ByteSizeLong(const MessageLite& base) { + const GetItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t GetItem::ByteSizeLong() const { + const GetItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.GetItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void GetItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.GetItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void GetItem::CopyFrom(const GetItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.GetItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void GetItem::InternalSwap(GetItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class SetSpell::_Internal { + public: +}; + +SetSpell::SetSpell(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SetSpell) +} +SetSpell::SetSpell( + ::google::protobuf::Arena* arena, const SetSpell& from) + : SetSpell(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SetSpell::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SetSpell::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, spellid_), + 0, + offsetof(Impl_, spelltype_) - + offsetof(Impl_, spellid_) + + sizeof(Impl_::spelltype_)); +} +SetSpell::~SetSpell() { + // @@protoc_insertion_point(destructor:dapi.commands.SetSpell) + SharedDtor(*this); +} +inline void SetSpell::SharedDtor(MessageLite& self) { + SetSpell& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SetSpell::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SetSpell(arena); +} +constexpr auto SetSpell::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetSpell), + alignof(SetSpell)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<23> SetSpell::_class_data_ = { + { + &_SetSpell_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SetSpell::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SetSpell::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SetSpell::ByteSizeLong, + &SetSpell::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SetSpell, _impl_._cached_size_), + true, + }, + "dapi.commands.SetSpell", +}; +const ::google::protobuf::internal::ClassData* SetSpell::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SetSpell::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SetSpell>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // sint32 spellType = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_)}}, + // sint32 spellID = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 spellID = 1; + {PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 spellType = 2; + {PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SetSpell::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SetSpell) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.spellid_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.spelltype_) - + reinterpret_cast(&_impl_.spellid_)) + sizeof(_impl_.spelltype_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SetSpell::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SetSpell& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SetSpell::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SetSpell& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SetSpell) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 spellID = 1; + if (this_._internal_spellid() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_spellid(), target); + } + + // sint32 spellType = 2; + if (this_._internal_spelltype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_spelltype(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SetSpell) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SetSpell::ByteSizeLong(const MessageLite& base) { + const SetSpell& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SetSpell::ByteSizeLong() const { + const SetSpell& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SetSpell) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // sint32 spellID = 1; + if (this_._internal_spellid() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_spellid()); + } + // sint32 spellType = 2; + if (this_._internal_spelltype() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_spelltype()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SetSpell::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SetSpell) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_spellid() != 0) { + _this->_impl_.spellid_ = from._impl_.spellid_; + } + if (from._internal_spelltype() != 0) { + _this->_impl_.spelltype_ = from._impl_.spelltype_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SetSpell::CopyFrom(const SetSpell& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SetSpell) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SetSpell::InternalSwap(SetSpell* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_) + + sizeof(SetSpell::_impl_.spelltype_) + - PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_)>( + reinterpret_cast(&_impl_.spellid_), + reinterpret_cast(&other->_impl_.spellid_)); +} + +// =================================================================== + +class CastMonster::_Internal { + public: +}; + +CastMonster::CastMonster(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.CastMonster) +} +CastMonster::CastMonster( + ::google::protobuf::Arena* arena, const CastMonster& from) + : CastMonster(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE CastMonster::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void CastMonster::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.index_ = {}; +} +CastMonster::~CastMonster() { + // @@protoc_insertion_point(destructor:dapi.commands.CastMonster) + SharedDtor(*this); +} +inline void CastMonster::SharedDtor(MessageLite& self) { + CastMonster& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* CastMonster::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CastMonster(arena); +} +constexpr auto CastMonster::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CastMonster), + alignof(CastMonster)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> CastMonster::_class_data_ = { + { + &_CastMonster_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CastMonster::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CastMonster::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &CastMonster::ByteSizeLong, + &CastMonster::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CastMonster, _impl_._cached_size_), + true, + }, + "dapi.commands.CastMonster", +}; +const ::google::protobuf::internal::ClassData* CastMonster::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CastMonster::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::CastMonster>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 index = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(CastMonster, _impl_.index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 index = 1; + {PROTOBUF_FIELD_OFFSET(CastMonster, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void CastMonster::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.CastMonster) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CastMonster::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CastMonster& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CastMonster::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CastMonster& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CastMonster) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 index = 1; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CastMonster) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CastMonster::ByteSizeLong(const MessageLite& base) { + const CastMonster& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CastMonster::ByteSizeLong() const { + const CastMonster& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CastMonster) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 index = 1; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void CastMonster::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CastMonster) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void CastMonster::CopyFrom(const CastMonster& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CastMonster) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CastMonster::InternalSwap(CastMonster* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.index_, other->_impl_.index_); +} + +// =================================================================== + +class CastXY::_Internal { + public: +}; + +CastXY::CastXY(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.CastXY) +} +CastXY::CastXY( + ::google::protobuf::Arena* arena, const CastXY& from) + : CastXY(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE CastXY::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void CastXY::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, x_), + 0, + offsetof(Impl_, y_) - + offsetof(Impl_, x_) + + sizeof(Impl_::y_)); +} +CastXY::~CastXY() { + // @@protoc_insertion_point(destructor:dapi.commands.CastXY) + SharedDtor(*this); +} +inline void CastXY::SharedDtor(MessageLite& self) { + CastXY& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* CastXY::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) CastXY(arena); +} +constexpr auto CastXY::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CastXY), + alignof(CastXY)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> CastXY::_class_data_ = { + { + &_CastXY_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &CastXY::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &CastXY::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &CastXY::ByteSizeLong, + &CastXY::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(CastXY, _impl_._cached_size_), + true, + }, + "dapi.commands.CastXY", +}; +const ::google::protobuf::internal::ClassData* CastXY::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> CastXY::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::CastXY>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // sint32 y = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_)}}, + // sint32 x = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 x = 1; + {PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 y = 2; + {PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void CastXY::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.CastXY) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.y_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.y_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* CastXY::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const CastXY& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* CastXY::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const CastXY& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CastXY) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 x = 1; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_x(), target); + } + + // sint32 y = 2; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_y(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CastXY) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t CastXY::ByteSizeLong(const MessageLite& base) { + const CastXY& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t CastXY::ByteSizeLong() const { + const CastXY& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CastXY) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // sint32 x = 1; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_x()); + } + // sint32 y = 2; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_y()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void CastXY::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CastXY) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void CastXY::CopyFrom(const CastXY& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CastXY) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void CastXY::InternalSwap(CastXY* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_) + + sizeof(CastXY::_impl_.y_) + - PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +// =================================================================== + +class ToggleInventory::_Internal { + public: +}; + +ToggleInventory::ToggleInventory(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleInventory) +} +ToggleInventory::ToggleInventory( + ::google::protobuf::Arena* arena, const ToggleInventory& from) + : ToggleInventory(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ToggleInventory::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ToggleInventory::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ToggleInventory::~ToggleInventory() { + // @@protoc_insertion_point(destructor:dapi.commands.ToggleInventory) + SharedDtor(*this); +} +inline void ToggleInventory::SharedDtor(MessageLite& self) { + ToggleInventory& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ToggleInventory::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ToggleInventory(arena); +} +constexpr auto ToggleInventory::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleInventory), + alignof(ToggleInventory)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<30> ToggleInventory::_class_data_ = { + { + &_ToggleInventory_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ToggleInventory::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ToggleInventory::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ToggleInventory::ByteSizeLong, + &ToggleInventory::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ToggleInventory, _impl_._cached_size_), + true, + }, + "dapi.commands.ToggleInventory", +}; +const ::google::protobuf::internal::ClassData* ToggleInventory::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleInventory::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::ToggleInventory>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ToggleInventory::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleInventory) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ToggleInventory::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ToggleInventory& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ToggleInventory::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ToggleInventory& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleInventory) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleInventory) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ToggleInventory::ByteSizeLong(const MessageLite& base) { + const ToggleInventory& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ToggleInventory::ByteSizeLong() const { + const ToggleInventory& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleInventory) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ToggleInventory::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleInventory) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ToggleInventory::CopyFrom(const ToggleInventory& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleInventory) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ToggleInventory::InternalSwap(ToggleInventory* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class PutInCursor::_Internal { + public: +}; + +PutInCursor::PutInCursor(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.PutInCursor) +} +PutInCursor::PutInCursor( + ::google::protobuf::Arena* arena, const PutInCursor& from) + : PutInCursor(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE PutInCursor::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void PutInCursor::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +PutInCursor::~PutInCursor() { + // @@protoc_insertion_point(destructor:dapi.commands.PutInCursor) + SharedDtor(*this); +} +inline void PutInCursor::SharedDtor(MessageLite& self) { + PutInCursor& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PutInCursor::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PutInCursor(arena); +} +constexpr auto PutInCursor::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PutInCursor), + alignof(PutInCursor)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> PutInCursor::_class_data_ = { + { + &_PutInCursor_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PutInCursor::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PutInCursor::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &PutInCursor::ByteSizeLong, + &PutInCursor::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_._cached_size_), + true, + }, + "dapi.commands.PutInCursor", +}; +const ::google::protobuf::internal::ClassData* PutInCursor::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> PutInCursor::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::PutInCursor>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void PutInCursor::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.PutInCursor) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* PutInCursor::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const PutInCursor& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* PutInCursor::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const PutInCursor& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.PutInCursor) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.PutInCursor) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t PutInCursor::ByteSizeLong(const MessageLite& base) { + const PutInCursor& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t PutInCursor::ByteSizeLong() const { + const PutInCursor& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.PutInCursor) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void PutInCursor::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.PutInCursor) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PutInCursor::CopyFrom(const PutInCursor& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.PutInCursor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void PutInCursor::InternalSwap(PutInCursor* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class PutCursorItem::_Internal { + public: +}; + +PutCursorItem::PutCursorItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.PutCursorItem) +} +PutCursorItem::PutCursorItem( + ::google::protobuf::Arena* arena, const PutCursorItem& from) + : PutCursorItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE PutCursorItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void PutCursorItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.target_ = {}; +} +PutCursorItem::~PutCursorItem() { + // @@protoc_insertion_point(destructor:dapi.commands.PutCursorItem) + SharedDtor(*this); +} +inline void PutCursorItem::SharedDtor(MessageLite& self) { + PutCursorItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PutCursorItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PutCursorItem(arena); +} +constexpr auto PutCursorItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PutCursorItem), + alignof(PutCursorItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<28> PutCursorItem::_class_data_ = { + { + &_PutCursorItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PutCursorItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PutCursorItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &PutCursorItem::ByteSizeLong, + &PutCursorItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_._cached_size_), + true, + }, + "dapi.commands.PutCursorItem", +}; +const ::google::protobuf::internal::ClassData* PutCursorItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> PutCursorItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::PutCursorItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // sint32 target = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_.target_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 target = 1; + {PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_.target_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void PutCursorItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.PutCursorItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.target_ = 0; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* PutCursorItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const PutCursorItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* PutCursorItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const PutCursorItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.PutCursorItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 target = 1; + if (this_._internal_target() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_target(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.PutCursorItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t PutCursorItem::ByteSizeLong(const MessageLite& base) { + const PutCursorItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t PutCursorItem::ByteSizeLong() const { + const PutCursorItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.PutCursorItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // sint32 target = 1; + if (this_._internal_target() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_target()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void PutCursorItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.PutCursorItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_target() != 0) { + _this->_impl_.target_ = from._impl_.target_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PutCursorItem::CopyFrom(const PutCursorItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.PutCursorItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void PutCursorItem::InternalSwap(PutCursorItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.target_, other->_impl_.target_); +} + +// =================================================================== + +class DropCursorItem::_Internal { + public: +}; + +DropCursorItem::DropCursorItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.DropCursorItem) +} +DropCursorItem::DropCursorItem( + ::google::protobuf::Arena* arena, const DropCursorItem& from) + : DropCursorItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE DropCursorItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void DropCursorItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +DropCursorItem::~DropCursorItem() { + // @@protoc_insertion_point(destructor:dapi.commands.DropCursorItem) + SharedDtor(*this); +} +inline void DropCursorItem::SharedDtor(MessageLite& self) { + DropCursorItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* DropCursorItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) DropCursorItem(arena); +} +constexpr auto DropCursorItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DropCursorItem), + alignof(DropCursorItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<29> DropCursorItem::_class_data_ = { + { + &_DropCursorItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DropCursorItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DropCursorItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &DropCursorItem::ByteSizeLong, + &DropCursorItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DropCursorItem, _impl_._cached_size_), + true, + }, + "dapi.commands.DropCursorItem", +}; +const ::google::protobuf::internal::ClassData* DropCursorItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> DropCursorItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::DropCursorItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void DropCursorItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.DropCursorItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* DropCursorItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const DropCursorItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* DropCursorItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const DropCursorItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.DropCursorItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.DropCursorItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t DropCursorItem::ByteSizeLong(const MessageLite& base) { + const DropCursorItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t DropCursorItem::ByteSizeLong() const { + const DropCursorItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.DropCursorItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void DropCursorItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.DropCursorItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void DropCursorItem::CopyFrom(const DropCursorItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.DropCursorItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void DropCursorItem::InternalSwap(DropCursorItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class UseItem::_Internal { + public: +}; + +UseItem::UseItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.UseItem) +} +UseItem::UseItem( + ::google::protobuf::Arena* arena, const UseItem& from) + : UseItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE UseItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void UseItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +UseItem::~UseItem() { + // @@protoc_insertion_point(destructor:dapi.commands.UseItem) + SharedDtor(*this); +} +inline void UseItem::SharedDtor(MessageLite& self) { + UseItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* UseItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) UseItem(arena); +} +constexpr auto UseItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseItem), + alignof(UseItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> UseItem::_class_data_ = { + { + &_UseItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &UseItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &UseItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &UseItem::ByteSizeLong, + &UseItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(UseItem, _impl_._cached_size_), + true, + }, + "dapi.commands.UseItem", +}; +const ::google::protobuf::internal::ClassData* UseItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> UseItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::UseItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(UseItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(UseItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void UseItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.UseItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* UseItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const UseItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* UseItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const UseItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.UseItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.UseItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t UseItem::ByteSizeLong(const MessageLite& base) { + const UseItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t UseItem::ByteSizeLong() const { + const UseItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.UseItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void UseItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.UseItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void UseItem::CopyFrom(const UseItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.UseItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void UseItem::InternalSwap(UseItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class IdentifyStoreItem::_Internal { + public: +}; + +IdentifyStoreItem::IdentifyStoreItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.IdentifyStoreItem) +} +IdentifyStoreItem::IdentifyStoreItem( + ::google::protobuf::Arena* arena, const IdentifyStoreItem& from) + : IdentifyStoreItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE IdentifyStoreItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void IdentifyStoreItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +IdentifyStoreItem::~IdentifyStoreItem() { + // @@protoc_insertion_point(destructor:dapi.commands.IdentifyStoreItem) + SharedDtor(*this); +} +inline void IdentifyStoreItem::SharedDtor(MessageLite& self) { + IdentifyStoreItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* IdentifyStoreItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) IdentifyStoreItem(arena); +} +constexpr auto IdentifyStoreItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IdentifyStoreItem), + alignof(IdentifyStoreItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<32> IdentifyStoreItem::_class_data_ = { + { + &_IdentifyStoreItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IdentifyStoreItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IdentifyStoreItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &IdentifyStoreItem::ByteSizeLong, + &IdentifyStoreItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_._cached_size_), + true, + }, + "dapi.commands.IdentifyStoreItem", +}; +const ::google::protobuf::internal::ClassData* IdentifyStoreItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IdentifyStoreItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::IdentifyStoreItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void IdentifyStoreItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.IdentifyStoreItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* IdentifyStoreItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const IdentifyStoreItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* IdentifyStoreItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const IdentifyStoreItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IdentifyStoreItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IdentifyStoreItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t IdentifyStoreItem::ByteSizeLong(const MessageLite& base) { + const IdentifyStoreItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t IdentifyStoreItem::ByteSizeLong() const { + const IdentifyStoreItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IdentifyStoreItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void IdentifyStoreItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IdentifyStoreItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void IdentifyStoreItem::CopyFrom(const IdentifyStoreItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IdentifyStoreItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void IdentifyStoreItem::InternalSwap(IdentifyStoreItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class DisarmTrap::_Internal { + public: +}; + +DisarmTrap::DisarmTrap(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.DisarmTrap) +} +DisarmTrap::DisarmTrap( + ::google::protobuf::Arena* arena, const DisarmTrap& from) + : DisarmTrap(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE DisarmTrap::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void DisarmTrap::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.index_ = {}; +} +DisarmTrap::~DisarmTrap() { + // @@protoc_insertion_point(destructor:dapi.commands.DisarmTrap) + SharedDtor(*this); +} +inline void DisarmTrap::SharedDtor(MessageLite& self) { + DisarmTrap& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* DisarmTrap::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) DisarmTrap(arena); +} +constexpr auto DisarmTrap::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DisarmTrap), + alignof(DisarmTrap)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<25> DisarmTrap::_class_data_ = { + { + &_DisarmTrap_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &DisarmTrap::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &DisarmTrap::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &DisarmTrap::ByteSizeLong, + &DisarmTrap::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_._cached_size_), + true, + }, + "dapi.commands.DisarmTrap", +}; +const ::google::protobuf::internal::ClassData* DisarmTrap::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> DisarmTrap::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::DisarmTrap>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 index = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_.index_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 index = 1; + {PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void DisarmTrap::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.DisarmTrap) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.index_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* DisarmTrap::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const DisarmTrap& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* DisarmTrap::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const DisarmTrap& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.DisarmTrap) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 index = 1; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_index(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.DisarmTrap) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t DisarmTrap::ByteSizeLong(const MessageLite& base) { + const DisarmTrap& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t DisarmTrap::ByteSizeLong() const { + const DisarmTrap& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.DisarmTrap) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 index = 1; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void DisarmTrap::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.DisarmTrap) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void DisarmTrap::CopyFrom(const DisarmTrap& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.DisarmTrap) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void DisarmTrap::InternalSwap(DisarmTrap* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.index_, other->_impl_.index_); +} + +// =================================================================== + +class SkillRepair::_Internal { + public: +}; + +SkillRepair::SkillRepair(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SkillRepair) +} +SkillRepair::SkillRepair( + ::google::protobuf::Arena* arena, const SkillRepair& from) + : SkillRepair(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SkillRepair::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SkillRepair::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +SkillRepair::~SkillRepair() { + // @@protoc_insertion_point(destructor:dapi.commands.SkillRepair) + SharedDtor(*this); +} +inline void SkillRepair::SharedDtor(MessageLite& self) { + SkillRepair& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SkillRepair::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SkillRepair(arena); +} +constexpr auto SkillRepair::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SkillRepair), + alignof(SkillRepair)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> SkillRepair::_class_data_ = { + { + &_SkillRepair_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SkillRepair::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SkillRepair::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SkillRepair::ByteSizeLong, + &SkillRepair::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_._cached_size_), + true, + }, + "dapi.commands.SkillRepair", +}; +const ::google::protobuf::internal::ClassData* SkillRepair::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SkillRepair::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SkillRepair>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SkillRepair::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SkillRepair) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SkillRepair::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SkillRepair& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SkillRepair::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SkillRepair& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SkillRepair) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SkillRepair) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SkillRepair::ByteSizeLong(const MessageLite& base) { + const SkillRepair& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SkillRepair::ByteSizeLong() const { + const SkillRepair& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SkillRepair) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SkillRepair::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SkillRepair) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SkillRepair::CopyFrom(const SkillRepair& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SkillRepair) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SkillRepair::InternalSwap(SkillRepair* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class SkillRecharge::_Internal { + public: +}; + +SkillRecharge::SkillRecharge(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SkillRecharge) +} +SkillRecharge::SkillRecharge( + ::google::protobuf::Arena* arena, const SkillRecharge& from) + : SkillRecharge(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SkillRecharge::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SkillRecharge::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +SkillRecharge::~SkillRecharge() { + // @@protoc_insertion_point(destructor:dapi.commands.SkillRecharge) + SharedDtor(*this); +} +inline void SkillRecharge::SharedDtor(MessageLite& self) { + SkillRecharge& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SkillRecharge::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SkillRecharge(arena); +} +constexpr auto SkillRecharge::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SkillRecharge), + alignof(SkillRecharge)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<28> SkillRecharge::_class_data_ = { + { + &_SkillRecharge_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SkillRecharge::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SkillRecharge::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SkillRecharge::ByteSizeLong, + &SkillRecharge::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_._cached_size_), + true, + }, + "dapi.commands.SkillRecharge", +}; +const ::google::protobuf::internal::ClassData* SkillRecharge::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SkillRecharge::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SkillRecharge>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SkillRecharge::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SkillRecharge) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SkillRecharge::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SkillRecharge& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SkillRecharge::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SkillRecharge& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SkillRecharge) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SkillRecharge) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SkillRecharge::ByteSizeLong(const MessageLite& base) { + const SkillRecharge& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SkillRecharge::ByteSizeLong() const { + const SkillRecharge& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SkillRecharge) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SkillRecharge::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SkillRecharge) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SkillRecharge::CopyFrom(const SkillRecharge& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SkillRecharge) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SkillRecharge::InternalSwap(SkillRecharge* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class ToggleMenu::_Internal { + public: +}; + +ToggleMenu::ToggleMenu(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleMenu) +} +ToggleMenu::ToggleMenu( + ::google::protobuf::Arena* arena, const ToggleMenu& from) + : ToggleMenu(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ToggleMenu::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ToggleMenu::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ToggleMenu::~ToggleMenu() { + // @@protoc_insertion_point(destructor:dapi.commands.ToggleMenu) + SharedDtor(*this); +} +inline void ToggleMenu::SharedDtor(MessageLite& self) { + ToggleMenu& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ToggleMenu::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ToggleMenu(arena); +} +constexpr auto ToggleMenu::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleMenu), + alignof(ToggleMenu)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<25> ToggleMenu::_class_data_ = { + { + &_ToggleMenu_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ToggleMenu::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ToggleMenu::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ToggleMenu::ByteSizeLong, + &ToggleMenu::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ToggleMenu, _impl_._cached_size_), + true, + }, + "dapi.commands.ToggleMenu", +}; +const ::google::protobuf::internal::ClassData* ToggleMenu::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleMenu::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::ToggleMenu>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ToggleMenu::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleMenu) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ToggleMenu::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ToggleMenu& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ToggleMenu::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ToggleMenu& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleMenu) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleMenu) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ToggleMenu::ByteSizeLong(const MessageLite& base) { + const ToggleMenu& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ToggleMenu::ByteSizeLong() const { + const ToggleMenu& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleMenu) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ToggleMenu::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleMenu) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ToggleMenu::CopyFrom(const ToggleMenu& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleMenu) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ToggleMenu::InternalSwap(ToggleMenu* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class SaveGame::_Internal { + public: +}; + +SaveGame::SaveGame(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.SaveGame) +} +SaveGame::SaveGame( + ::google::protobuf::Arena* arena, const SaveGame& from) + : SaveGame(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE SaveGame::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void SaveGame::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +SaveGame::~SaveGame() { + // @@protoc_insertion_point(destructor:dapi.commands.SaveGame) + SharedDtor(*this); +} +inline void SaveGame::SharedDtor(MessageLite& self) { + SaveGame& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* SaveGame::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) SaveGame(arena); +} +constexpr auto SaveGame::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SaveGame), + alignof(SaveGame)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<23> SaveGame::_class_data_ = { + { + &_SaveGame_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &SaveGame::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &SaveGame::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &SaveGame::ByteSizeLong, + &SaveGame::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(SaveGame, _impl_._cached_size_), + true, + }, + "dapi.commands.SaveGame", +}; +const ::google::protobuf::internal::ClassData* SaveGame::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SaveGame::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::SaveGame>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void SaveGame::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.SaveGame) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* SaveGame::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const SaveGame& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* SaveGame::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const SaveGame& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SaveGame) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SaveGame) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t SaveGame::ByteSizeLong(const MessageLite& base) { + const SaveGame& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t SaveGame::ByteSizeLong() const { + const SaveGame& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SaveGame) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void SaveGame::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SaveGame) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void SaveGame::CopyFrom(const SaveGame& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SaveGame) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void SaveGame::InternalSwap(SaveGame* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class Quit::_Internal { + public: +}; + +Quit::Quit(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.Quit) +} +Quit::Quit( + ::google::protobuf::Arena* arena, const Quit& from) + : Quit(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE Quit::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void Quit::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Quit::~Quit() { + // @@protoc_insertion_point(destructor:dapi.commands.Quit) + SharedDtor(*this); +} +inline void Quit::SharedDtor(MessageLite& self) { + Quit& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* Quit::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Quit(arena); +} +constexpr auto Quit::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Quit), + alignof(Quit)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<19> Quit::_class_data_ = { + { + &_Quit_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Quit::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Quit::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &Quit::ByteSizeLong, + &Quit::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Quit, _impl_._cached_size_), + true, + }, + "dapi.commands.Quit", +}; +const ::google::protobuf::internal::ClassData* Quit::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> Quit::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::Quit>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void Quit::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.Quit) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Quit::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Quit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Quit::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Quit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Quit) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Quit) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Quit::ByteSizeLong(const MessageLite& base) { + const Quit& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Quit::ByteSizeLong() const { + const Quit& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Quit) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void Quit::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Quit) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void Quit::CopyFrom(const Quit& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Quit) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Quit::InternalSwap(Quit* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class ClearCursor::_Internal { + public: +}; + +ClearCursor::ClearCursor(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.ClearCursor) +} +ClearCursor::ClearCursor( + ::google::protobuf::Arena* arena, const ClearCursor& from) + : ClearCursor(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ClearCursor::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ClearCursor::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ClearCursor::~ClearCursor() { + // @@protoc_insertion_point(destructor:dapi.commands.ClearCursor) + SharedDtor(*this); +} +inline void ClearCursor::SharedDtor(MessageLite& self) { + ClearCursor& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ClearCursor::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ClearCursor(arena); +} +constexpr auto ClearCursor::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ClearCursor), + alignof(ClearCursor)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> ClearCursor::_class_data_ = { + { + &_ClearCursor_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClearCursor::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClearCursor::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ClearCursor::ByteSizeLong, + &ClearCursor::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClearCursor, _impl_._cached_size_), + true, + }, + "dapi.commands.ClearCursor", +}; +const ::google::protobuf::internal::ClassData* ClearCursor::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ClearCursor::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::ClearCursor>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ClearCursor::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.ClearCursor) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ClearCursor::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ClearCursor& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ClearCursor::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ClearCursor& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ClearCursor) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ClearCursor) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ClearCursor::ByteSizeLong(const MessageLite& base) { + const ClearCursor& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ClearCursor::ByteSizeLong() const { + const ClearCursor& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ClearCursor) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ClearCursor::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ClearCursor) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ClearCursor::CopyFrom(const ClearCursor& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ClearCursor) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ClearCursor::InternalSwap(ClearCursor* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class IdentifyItem::_Internal { + public: +}; + +IdentifyItem::IdentifyItem(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.IdentifyItem) +} +IdentifyItem::IdentifyItem( + ::google::protobuf::Arena* arena, const IdentifyItem& from) + : IdentifyItem(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE IdentifyItem::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void IdentifyItem::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.id_ = {}; +} +IdentifyItem::~IdentifyItem() { + // @@protoc_insertion_point(destructor:dapi.commands.IdentifyItem) + SharedDtor(*this); +} +inline void IdentifyItem::SharedDtor(MessageLite& self) { + IdentifyItem& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* IdentifyItem::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) IdentifyItem(arena); +} +constexpr auto IdentifyItem::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IdentifyItem), + alignof(IdentifyItem)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<27> IdentifyItem::_class_data_ = { + { + &_IdentifyItem_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &IdentifyItem::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &IdentifyItem::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &IdentifyItem::ByteSizeLong, + &IdentifyItem::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_._cached_size_), + true, + }, + "dapi.commands.IdentifyItem", +}; +const ::google::protobuf::internal::ClassData* IdentifyItem::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IdentifyItem::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::IdentifyItem>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void IdentifyItem::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.IdentifyItem) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.id_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* IdentifyItem::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const IdentifyItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* IdentifyItem::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const IdentifyItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IdentifyItem) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IdentifyItem) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t IdentifyItem::ByteSizeLong(const MessageLite& base) { + const IdentifyItem& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t IdentifyItem::ByteSizeLong() const { + const IdentifyItem& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IdentifyItem) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void IdentifyItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IdentifyItem) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void IdentifyItem::CopyFrom(const IdentifyItem& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IdentifyItem) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void IdentifyItem::InternalSwap(IdentifyItem* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.id_, other->_impl_.id_); +} + +// =================================================================== + +class Command::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::dapi::commands::Command, _impl_._oneof_case_); +}; + +void Command::set_allocated_move(::dapi::commands::Move* move) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (move) { + ::google::protobuf::Arena* submessage_arena = move->GetArena(); + if (message_arena != submessage_arena) { + move = ::google::protobuf::internal::GetOwnedMessage(message_arena, move, submessage_arena); + } + set_has_move(); + _impl_.command_.move_ = move; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.move) +} +void Command::set_allocated_talk(::dapi::commands::Talk* talk) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (talk) { + ::google::protobuf::Arena* submessage_arena = talk->GetArena(); + if (message_arena != submessage_arena) { + talk = ::google::protobuf::internal::GetOwnedMessage(message_arena, talk, submessage_arena); + } + set_has_talk(); + _impl_.command_.talk_ = talk; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.talk) +} +void Command::set_allocated_option(::dapi::commands::SelectStoreOption* option) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (option) { + ::google::protobuf::Arena* submessage_arena = option->GetArena(); + if (message_arena != submessage_arena) { + option = ::google::protobuf::internal::GetOwnedMessage(message_arena, option, submessage_arena); + } + set_has_option(); + _impl_.command_.option_ = option; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.option) +} +void Command::set_allocated_buyitem(::dapi::commands::BuyItem* buyitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (buyitem) { + ::google::protobuf::Arena* submessage_arena = buyitem->GetArena(); + if (message_arena != submessage_arena) { + buyitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, buyitem, submessage_arena); + } + set_has_buyitem(); + _impl_.command_.buyitem_ = buyitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.buyItem) +} +void Command::set_allocated_sellitem(::dapi::commands::SellItem* sellitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (sellitem) { + ::google::protobuf::Arena* submessage_arena = sellitem->GetArena(); + if (message_arena != submessage_arena) { + sellitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, sellitem, submessage_arena); + } + set_has_sellitem(); + _impl_.command_.sellitem_ = sellitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.sellItem) +} +void Command::set_allocated_rechargeitem(::dapi::commands::RechargeItem* rechargeitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (rechargeitem) { + ::google::protobuf::Arena* submessage_arena = rechargeitem->GetArena(); + if (message_arena != submessage_arena) { + rechargeitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, rechargeitem, submessage_arena); + } + set_has_rechargeitem(); + _impl_.command_.rechargeitem_ = rechargeitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.rechargeItem) +} +void Command::set_allocated_repairitem(::dapi::commands::RepairItem* repairitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (repairitem) { + ::google::protobuf::Arena* submessage_arena = repairitem->GetArena(); + if (message_arena != submessage_arena) { + repairitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, repairitem, submessage_arena); + } + set_has_repairitem(); + _impl_.command_.repairitem_ = repairitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.repairItem) +} +void Command::set_allocated_attackmonster(::dapi::commands::AttackMonster* attackmonster) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (attackmonster) { + ::google::protobuf::Arena* submessage_arena = attackmonster->GetArena(); + if (message_arena != submessage_arena) { + attackmonster = ::google::protobuf::internal::GetOwnedMessage(message_arena, attackmonster, submessage_arena); + } + set_has_attackmonster(); + _impl_.command_.attackmonster_ = attackmonster; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.attackMonster) +} +void Command::set_allocated_attackxy(::dapi::commands::AttackXY* attackxy) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (attackxy) { + ::google::protobuf::Arena* submessage_arena = attackxy->GetArena(); + if (message_arena != submessage_arena) { + attackxy = ::google::protobuf::internal::GetOwnedMessage(message_arena, attackxy, submessage_arena); + } + set_has_attackxy(); + _impl_.command_.attackxy_ = attackxy; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.attackXY) +} +void Command::set_allocated_operateobject(::dapi::commands::OperateObject* operateobject) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (operateobject) { + ::google::protobuf::Arena* submessage_arena = operateobject->GetArena(); + if (message_arena != submessage_arena) { + operateobject = ::google::protobuf::internal::GetOwnedMessage(message_arena, operateobject, submessage_arena); + } + set_has_operateobject(); + _impl_.command_.operateobject_ = operateobject; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.operateObject) +} +void Command::set_allocated_usebeltitem(::dapi::commands::UseBeltItem* usebeltitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (usebeltitem) { + ::google::protobuf::Arena* submessage_arena = usebeltitem->GetArena(); + if (message_arena != submessage_arena) { + usebeltitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, usebeltitem, submessage_arena); + } + set_has_usebeltitem(); + _impl_.command_.usebeltitem_ = usebeltitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.useBeltItem) +} +void Command::set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* togglecharactersheet) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (togglecharactersheet) { + ::google::protobuf::Arena* submessage_arena = togglecharactersheet->GetArena(); + if (message_arena != submessage_arena) { + togglecharactersheet = ::google::protobuf::internal::GetOwnedMessage(message_arena, togglecharactersheet, submessage_arena); + } + set_has_togglecharactersheet(); + _impl_.command_.togglecharactersheet_ = togglecharactersheet; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleCharacterSheet) +} +void Command::set_allocated_increasestat(::dapi::commands::IncreaseStat* increasestat) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (increasestat) { + ::google::protobuf::Arena* submessage_arena = increasestat->GetArena(); + if (message_arena != submessage_arena) { + increasestat = ::google::protobuf::internal::GetOwnedMessage(message_arena, increasestat, submessage_arena); + } + set_has_increasestat(); + _impl_.command_.increasestat_ = increasestat; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.increaseStat) +} +void Command::set_allocated_getitem(::dapi::commands::GetItem* getitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (getitem) { + ::google::protobuf::Arena* submessage_arena = getitem->GetArena(); + if (message_arena != submessage_arena) { + getitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, getitem, submessage_arena); + } + set_has_getitem(); + _impl_.command_.getitem_ = getitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.getItem) +} +void Command::set_allocated_setspell(::dapi::commands::SetSpell* setspell) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (setspell) { + ::google::protobuf::Arena* submessage_arena = setspell->GetArena(); + if (message_arena != submessage_arena) { + setspell = ::google::protobuf::internal::GetOwnedMessage(message_arena, setspell, submessage_arena); + } + set_has_setspell(); + _impl_.command_.setspell_ = setspell; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.setSpell) +} +void Command::set_allocated_castmonster(::dapi::commands::CastMonster* castmonster) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (castmonster) { + ::google::protobuf::Arena* submessage_arena = castmonster->GetArena(); + if (message_arena != submessage_arena) { + castmonster = ::google::protobuf::internal::GetOwnedMessage(message_arena, castmonster, submessage_arena); + } + set_has_castmonster(); + _impl_.command_.castmonster_ = castmonster; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.castMonster) +} +void Command::set_allocated_castxy(::dapi::commands::CastXY* castxy) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (castxy) { + ::google::protobuf::Arena* submessage_arena = castxy->GetArena(); + if (message_arena != submessage_arena) { + castxy = ::google::protobuf::internal::GetOwnedMessage(message_arena, castxy, submessage_arena); + } + set_has_castxy(); + _impl_.command_.castxy_ = castxy; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.castXY) +} +void Command::set_allocated_toggleinventory(::dapi::commands::ToggleInventory* toggleinventory) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (toggleinventory) { + ::google::protobuf::Arena* submessage_arena = toggleinventory->GetArena(); + if (message_arena != submessage_arena) { + toggleinventory = ::google::protobuf::internal::GetOwnedMessage(message_arena, toggleinventory, submessage_arena); + } + set_has_toggleinventory(); + _impl_.command_.toggleinventory_ = toggleinventory; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleInventory) +} +void Command::set_allocated_putincursor(::dapi::commands::PutInCursor* putincursor) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (putincursor) { + ::google::protobuf::Arena* submessage_arena = putincursor->GetArena(); + if (message_arena != submessage_arena) { + putincursor = ::google::protobuf::internal::GetOwnedMessage(message_arena, putincursor, submessage_arena); + } + set_has_putincursor(); + _impl_.command_.putincursor_ = putincursor; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.putInCursor) +} +void Command::set_allocated_putcursoritem(::dapi::commands::PutCursorItem* putcursoritem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (putcursoritem) { + ::google::protobuf::Arena* submessage_arena = putcursoritem->GetArena(); + if (message_arena != submessage_arena) { + putcursoritem = ::google::protobuf::internal::GetOwnedMessage(message_arena, putcursoritem, submessage_arena); + } + set_has_putcursoritem(); + _impl_.command_.putcursoritem_ = putcursoritem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.putCursorItem) +} +void Command::set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* dropcursoritem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (dropcursoritem) { + ::google::protobuf::Arena* submessage_arena = dropcursoritem->GetArena(); + if (message_arena != submessage_arena) { + dropcursoritem = ::google::protobuf::internal::GetOwnedMessage(message_arena, dropcursoritem, submessage_arena); + } + set_has_dropcursoritem(); + _impl_.command_.dropcursoritem_ = dropcursoritem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.dropCursorItem) +} +void Command::set_allocated_useitem(::dapi::commands::UseItem* useitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (useitem) { + ::google::protobuf::Arena* submessage_arena = useitem->GetArena(); + if (message_arena != submessage_arena) { + useitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, useitem, submessage_arena); + } + set_has_useitem(); + _impl_.command_.useitem_ = useitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.useItem) +} +void Command::set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* identifystoreitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (identifystoreitem) { + ::google::protobuf::Arena* submessage_arena = identifystoreitem->GetArena(); + if (message_arena != submessage_arena) { + identifystoreitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, identifystoreitem, submessage_arena); + } + set_has_identifystoreitem(); + _impl_.command_.identifystoreitem_ = identifystoreitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.identifyStoreItem) +} +void Command::set_allocated_cancelqtext(::dapi::commands::CancelQText* cancelqtext) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (cancelqtext) { + ::google::protobuf::Arena* submessage_arena = cancelqtext->GetArena(); + if (message_arena != submessage_arena) { + cancelqtext = ::google::protobuf::internal::GetOwnedMessage(message_arena, cancelqtext, submessage_arena); + } + set_has_cancelqtext(); + _impl_.command_.cancelqtext_ = cancelqtext; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.cancelQText) +} +void Command::set_allocated_setfps(::dapi::commands::SetFPS* setfps) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (setfps) { + ::google::protobuf::Arena* submessage_arena = setfps->GetArena(); + if (message_arena != submessage_arena) { + setfps = ::google::protobuf::internal::GetOwnedMessage(message_arena, setfps, submessage_arena); + } + set_has_setfps(); + _impl_.command_.setfps_ = setfps; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.setFPS) +} +void Command::set_allocated_disarmtrap(::dapi::commands::DisarmTrap* disarmtrap) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (disarmtrap) { + ::google::protobuf::Arena* submessage_arena = disarmtrap->GetArena(); + if (message_arena != submessage_arena) { + disarmtrap = ::google::protobuf::internal::GetOwnedMessage(message_arena, disarmtrap, submessage_arena); + } + set_has_disarmtrap(); + _impl_.command_.disarmtrap_ = disarmtrap; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.disarmTrap) +} +void Command::set_allocated_skillrepair(::dapi::commands::SkillRepair* skillrepair) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (skillrepair) { + ::google::protobuf::Arena* submessage_arena = skillrepair->GetArena(); + if (message_arena != submessage_arena) { + skillrepair = ::google::protobuf::internal::GetOwnedMessage(message_arena, skillrepair, submessage_arena); + } + set_has_skillrepair(); + _impl_.command_.skillrepair_ = skillrepair; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.skillRepair) +} +void Command::set_allocated_skillrecharge(::dapi::commands::SkillRecharge* skillrecharge) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (skillrecharge) { + ::google::protobuf::Arena* submessage_arena = skillrecharge->GetArena(); + if (message_arena != submessage_arena) { + skillrecharge = ::google::protobuf::internal::GetOwnedMessage(message_arena, skillrecharge, submessage_arena); + } + set_has_skillrecharge(); + _impl_.command_.skillrecharge_ = skillrecharge; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.skillRecharge) +} +void Command::set_allocated_togglemenu(::dapi::commands::ToggleMenu* togglemenu) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (togglemenu) { + ::google::protobuf::Arena* submessage_arena = togglemenu->GetArena(); + if (message_arena != submessage_arena) { + togglemenu = ::google::protobuf::internal::GetOwnedMessage(message_arena, togglemenu, submessage_arena); + } + set_has_togglemenu(); + _impl_.command_.togglemenu_ = togglemenu; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleMenu) +} +void Command::set_allocated_savegame(::dapi::commands::SaveGame* savegame) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (savegame) { + ::google::protobuf::Arena* submessage_arena = savegame->GetArena(); + if (message_arena != submessage_arena) { + savegame = ::google::protobuf::internal::GetOwnedMessage(message_arena, savegame, submessage_arena); + } + set_has_savegame(); + _impl_.command_.savegame_ = savegame; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.saveGame) +} +void Command::set_allocated_quit(::dapi::commands::Quit* quit) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (quit) { + ::google::protobuf::Arena* submessage_arena = quit->GetArena(); + if (message_arena != submessage_arena) { + quit = ::google::protobuf::internal::GetOwnedMessage(message_arena, quit, submessage_arena); + } + set_has_quit(); + _impl_.command_.quit_ = quit; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.quit) +} +void Command::set_allocated_clearcursor(::dapi::commands::ClearCursor* clearcursor) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (clearcursor) { + ::google::protobuf::Arena* submessage_arena = clearcursor->GetArena(); + if (message_arena != submessage_arena) { + clearcursor = ::google::protobuf::internal::GetOwnedMessage(message_arena, clearcursor, submessage_arena); + } + set_has_clearcursor(); + _impl_.command_.clearcursor_ = clearcursor; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.clearCursor) +} +void Command::set_allocated_identifyitem(::dapi::commands::IdentifyItem* identifyitem) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_command(); + if (identifyitem) { + ::google::protobuf::Arena* submessage_arena = identifyitem->GetArena(); + if (message_arena != submessage_arena) { + identifyitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, identifyitem, submessage_arena); + } + set_has_identifyitem(); + _impl_.command_.identifyitem_ = identifyitem; + } + // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.identifyItem) +} +Command::Command(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.commands.Command) +} +inline PROTOBUF_NDEBUG_INLINE Command::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::commands::Command& from_msg) + : command_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +Command::Command( + ::google::protobuf::Arena* arena, + const Command& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Command* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + switch (command_case()) { + case COMMAND_NOT_SET: + break; + case kMove: + _impl_.command_.move_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Move>(arena, *from._impl_.command_.move_); + break; + case kTalk: + _impl_.command_.talk_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Talk>(arena, *from._impl_.command_.talk_); + break; + case kOption: + _impl_.command_.option_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SelectStoreOption>(arena, *from._impl_.command_.option_); + break; + case kBuyItem: + _impl_.command_.buyitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::BuyItem>(arena, *from._impl_.command_.buyitem_); + break; + case kSellItem: + _impl_.command_.sellitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SellItem>(arena, *from._impl_.command_.sellitem_); + break; + case kRechargeItem: + _impl_.command_.rechargeitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RechargeItem>(arena, *from._impl_.command_.rechargeitem_); + break; + case kRepairItem: + _impl_.command_.repairitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RepairItem>(arena, *from._impl_.command_.repairitem_); + break; + case kAttackMonster: + _impl_.command_.attackmonster_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackMonster>(arena, *from._impl_.command_.attackmonster_); + break; + case kAttackXY: + _impl_.command_.attackxy_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackXY>(arena, *from._impl_.command_.attackxy_); + break; + case kOperateObject: + _impl_.command_.operateobject_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::OperateObject>(arena, *from._impl_.command_.operateobject_); + break; + case kUseBeltItem: + _impl_.command_.usebeltitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseBeltItem>(arena, *from._impl_.command_.usebeltitem_); + break; + case kToggleCharacterSheet: + _impl_.command_.togglecharactersheet_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleCharacterSheet>(arena, *from._impl_.command_.togglecharactersheet_); + break; + case kIncreaseStat: + _impl_.command_.increasestat_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IncreaseStat>(arena, *from._impl_.command_.increasestat_); + break; + case kGetItem: + _impl_.command_.getitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::GetItem>(arena, *from._impl_.command_.getitem_); + break; + case kSetSpell: + _impl_.command_.setspell_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetSpell>(arena, *from._impl_.command_.setspell_); + break; + case kCastMonster: + _impl_.command_.castmonster_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastMonster>(arena, *from._impl_.command_.castmonster_); + break; + case kCastXY: + _impl_.command_.castxy_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastXY>(arena, *from._impl_.command_.castxy_); + break; + case kToggleInventory: + _impl_.command_.toggleinventory_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleInventory>(arena, *from._impl_.command_.toggleinventory_); + break; + case kPutInCursor: + _impl_.command_.putincursor_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutInCursor>(arena, *from._impl_.command_.putincursor_); + break; + case kPutCursorItem: + _impl_.command_.putcursoritem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutCursorItem>(arena, *from._impl_.command_.putcursoritem_); + break; + case kDropCursorItem: + _impl_.command_.dropcursoritem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DropCursorItem>(arena, *from._impl_.command_.dropcursoritem_); + break; + case kUseItem: + _impl_.command_.useitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseItem>(arena, *from._impl_.command_.useitem_); + break; + case kIdentifyStoreItem: + _impl_.command_.identifystoreitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyStoreItem>(arena, *from._impl_.command_.identifystoreitem_); + break; + case kCancelQText: + _impl_.command_.cancelqtext_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CancelQText>(arena, *from._impl_.command_.cancelqtext_); + break; + case kSetFPS: + _impl_.command_.setfps_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetFPS>(arena, *from._impl_.command_.setfps_); + break; + case kDisarmTrap: + _impl_.command_.disarmtrap_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DisarmTrap>(arena, *from._impl_.command_.disarmtrap_); + break; + case kSkillRepair: + _impl_.command_.skillrepair_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRepair>(arena, *from._impl_.command_.skillrepair_); + break; + case kSkillRecharge: + _impl_.command_.skillrecharge_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRecharge>(arena, *from._impl_.command_.skillrecharge_); + break; + case kToggleMenu: + _impl_.command_.togglemenu_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleMenu>(arena, *from._impl_.command_.togglemenu_); + break; + case kSaveGame: + _impl_.command_.savegame_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SaveGame>(arena, *from._impl_.command_.savegame_); + break; + case kQuit: + _impl_.command_.quit_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Quit>(arena, *from._impl_.command_.quit_); + break; + case kClearCursor: + _impl_.command_.clearcursor_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ClearCursor>(arena, *from._impl_.command_.clearcursor_); + break; + case kIdentifyItem: + _impl_.command_.identifyitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyItem>(arena, *from._impl_.command_.identifyitem_); + break; + } + + // @@protoc_insertion_point(copy_constructor:dapi.commands.Command) +} +inline PROTOBUF_NDEBUG_INLINE Command::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : command_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void Command::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Command::~Command() { + // @@protoc_insertion_point(destructor:dapi.commands.Command) + SharedDtor(*this); +} +inline void Command::SharedDtor(MessageLite& self) { + Command& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_command()) { + this_.clear_command(); + } + this_._impl_.~Impl_(); +} + +void Command::clear_command() { +// @@protoc_insertion_point(one_of_clear_start:dapi.commands.Command) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (command_case()) { + case kMove: { + if (GetArena() == nullptr) { + delete _impl_.command_.move_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.move_ != nullptr) { + _impl_.command_.move_->Clear(); + } + } + break; + } + case kTalk: { + if (GetArena() == nullptr) { + delete _impl_.command_.talk_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.talk_ != nullptr) { + _impl_.command_.talk_->Clear(); + } + } + break; + } + case kOption: { + if (GetArena() == nullptr) { + delete _impl_.command_.option_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.option_ != nullptr) { + _impl_.command_.option_->Clear(); + } + } + break; + } + case kBuyItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.buyitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.buyitem_ != nullptr) { + _impl_.command_.buyitem_->Clear(); + } + } + break; + } + case kSellItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.sellitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.sellitem_ != nullptr) { + _impl_.command_.sellitem_->Clear(); + } + } + break; + } + case kRechargeItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.rechargeitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.rechargeitem_ != nullptr) { + _impl_.command_.rechargeitem_->Clear(); + } + } + break; + } + case kRepairItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.repairitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.repairitem_ != nullptr) { + _impl_.command_.repairitem_->Clear(); + } + } + break; + } + case kAttackMonster: { + if (GetArena() == nullptr) { + delete _impl_.command_.attackmonster_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.attackmonster_ != nullptr) { + _impl_.command_.attackmonster_->Clear(); + } + } + break; + } + case kAttackXY: { + if (GetArena() == nullptr) { + delete _impl_.command_.attackxy_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.attackxy_ != nullptr) { + _impl_.command_.attackxy_->Clear(); + } + } + break; + } + case kOperateObject: { + if (GetArena() == nullptr) { + delete _impl_.command_.operateobject_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.operateobject_ != nullptr) { + _impl_.command_.operateobject_->Clear(); + } + } + break; + } + case kUseBeltItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.usebeltitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.usebeltitem_ != nullptr) { + _impl_.command_.usebeltitem_->Clear(); + } + } + break; + } + case kToggleCharacterSheet: { + if (GetArena() == nullptr) { + delete _impl_.command_.togglecharactersheet_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.togglecharactersheet_ != nullptr) { + _impl_.command_.togglecharactersheet_->Clear(); + } + } + break; + } + case kIncreaseStat: { + if (GetArena() == nullptr) { + delete _impl_.command_.increasestat_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.increasestat_ != nullptr) { + _impl_.command_.increasestat_->Clear(); + } + } + break; + } + case kGetItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.getitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.getitem_ != nullptr) { + _impl_.command_.getitem_->Clear(); + } + } + break; + } + case kSetSpell: { + if (GetArena() == nullptr) { + delete _impl_.command_.setspell_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.setspell_ != nullptr) { + _impl_.command_.setspell_->Clear(); + } + } + break; + } + case kCastMonster: { + if (GetArena() == nullptr) { + delete _impl_.command_.castmonster_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.castmonster_ != nullptr) { + _impl_.command_.castmonster_->Clear(); + } + } + break; + } + case kCastXY: { + if (GetArena() == nullptr) { + delete _impl_.command_.castxy_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.castxy_ != nullptr) { + _impl_.command_.castxy_->Clear(); + } + } + break; + } + case kToggleInventory: { + if (GetArena() == nullptr) { + delete _impl_.command_.toggleinventory_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.toggleinventory_ != nullptr) { + _impl_.command_.toggleinventory_->Clear(); + } + } + break; + } + case kPutInCursor: { + if (GetArena() == nullptr) { + delete _impl_.command_.putincursor_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.putincursor_ != nullptr) { + _impl_.command_.putincursor_->Clear(); + } + } + break; + } + case kPutCursorItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.putcursoritem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.putcursoritem_ != nullptr) { + _impl_.command_.putcursoritem_->Clear(); + } + } + break; + } + case kDropCursorItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.dropcursoritem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.dropcursoritem_ != nullptr) { + _impl_.command_.dropcursoritem_->Clear(); + } + } + break; + } + case kUseItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.useitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.useitem_ != nullptr) { + _impl_.command_.useitem_->Clear(); + } + } + break; + } + case kIdentifyStoreItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.identifystoreitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.identifystoreitem_ != nullptr) { + _impl_.command_.identifystoreitem_->Clear(); + } + } + break; + } + case kCancelQText: { + if (GetArena() == nullptr) { + delete _impl_.command_.cancelqtext_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.cancelqtext_ != nullptr) { + _impl_.command_.cancelqtext_->Clear(); + } + } + break; + } + case kSetFPS: { + if (GetArena() == nullptr) { + delete _impl_.command_.setfps_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.setfps_ != nullptr) { + _impl_.command_.setfps_->Clear(); + } + } + break; + } + case kDisarmTrap: { + if (GetArena() == nullptr) { + delete _impl_.command_.disarmtrap_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.disarmtrap_ != nullptr) { + _impl_.command_.disarmtrap_->Clear(); + } + } + break; + } + case kSkillRepair: { + if (GetArena() == nullptr) { + delete _impl_.command_.skillrepair_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.skillrepair_ != nullptr) { + _impl_.command_.skillrepair_->Clear(); + } + } + break; + } + case kSkillRecharge: { + if (GetArena() == nullptr) { + delete _impl_.command_.skillrecharge_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.skillrecharge_ != nullptr) { + _impl_.command_.skillrecharge_->Clear(); + } + } + break; + } + case kToggleMenu: { + if (GetArena() == nullptr) { + delete _impl_.command_.togglemenu_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.togglemenu_ != nullptr) { + _impl_.command_.togglemenu_->Clear(); + } + } + break; + } + case kSaveGame: { + if (GetArena() == nullptr) { + delete _impl_.command_.savegame_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.savegame_ != nullptr) { + _impl_.command_.savegame_->Clear(); + } + } + break; + } + case kQuit: { + if (GetArena() == nullptr) { + delete _impl_.command_.quit_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.quit_ != nullptr) { + _impl_.command_.quit_->Clear(); + } + } + break; + } + case kClearCursor: { + if (GetArena() == nullptr) { + delete _impl_.command_.clearcursor_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.clearcursor_ != nullptr) { + _impl_.command_.clearcursor_->Clear(); + } + } + break; + } + case kIdentifyItem: { + if (GetArena() == nullptr) { + delete _impl_.command_.identifyitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.identifyitem_ != nullptr) { + _impl_.command_.identifyitem_->Clear(); + } + } + break; + } + case COMMAND_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = COMMAND_NOT_SET; +} + + +inline void* Command::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Command(arena); +} +constexpr auto Command::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Command), + alignof(Command)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> Command::_class_data_ = { + { + &_Command_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Command::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Command::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &Command::ByteSizeLong, + &Command::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Command, _impl_._cached_size_), + true, + }, + "dapi.commands.Command", +}; +const ::google::protobuf::internal::ClassData* Command::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 33, 33, 0, 7> Command::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 33, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 0, // skipmap + offsetof(decltype(_table_), field_entries), + 33, // num_field_entries + 33, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::commands::Command>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 33, 0, 1, + 65534, 32, + 65535, 65535 + }}, {{ + // .dapi.commands.Move move = 1; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.move_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.Talk talk = 2; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.talk_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SelectStoreOption option = 3; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.option_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.BuyItem buyItem = 4; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.buyitem_), _Internal::kOneofCaseOffset + 0, 3, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SellItem sellItem = 5; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.sellitem_), _Internal::kOneofCaseOffset + 0, 4, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.RechargeItem rechargeItem = 6; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.rechargeitem_), _Internal::kOneofCaseOffset + 0, 5, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.RepairItem repairItem = 7; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.repairitem_), _Internal::kOneofCaseOffset + 0, 6, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.AttackMonster attackMonster = 8; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.attackmonster_), _Internal::kOneofCaseOffset + 0, 7, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.AttackXY attackXY = 9; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.attackxy_), _Internal::kOneofCaseOffset + 0, 8, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.OperateObject operateObject = 10; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.operateobject_), _Internal::kOneofCaseOffset + 0, 9, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.UseBeltItem useBeltItem = 11; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.usebeltitem_), _Internal::kOneofCaseOffset + 0, 10, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.togglecharactersheet_), _Internal::kOneofCaseOffset + 0, 11, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.IncreaseStat increaseStat = 13; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.increasestat_), _Internal::kOneofCaseOffset + 0, 12, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.GetItem getItem = 14; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.getitem_), _Internal::kOneofCaseOffset + 0, 13, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SetSpell setSpell = 15; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.setspell_), _Internal::kOneofCaseOffset + 0, 14, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.CastMonster castMonster = 16; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.castmonster_), _Internal::kOneofCaseOffset + 0, 15, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.CastXY castXY = 17; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.castxy_), _Internal::kOneofCaseOffset + 0, 16, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.ToggleInventory toggleInventory = 18; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.toggleinventory_), _Internal::kOneofCaseOffset + 0, 17, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.PutInCursor putInCursor = 19; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.putincursor_), _Internal::kOneofCaseOffset + 0, 18, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.PutCursorItem putCursorItem = 20; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.putcursoritem_), _Internal::kOneofCaseOffset + 0, 19, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.DropCursorItem dropCursorItem = 21; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.dropcursoritem_), _Internal::kOneofCaseOffset + 0, 20, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.UseItem useItem = 22; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.useitem_), _Internal::kOneofCaseOffset + 0, 21, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.identifystoreitem_), _Internal::kOneofCaseOffset + 0, 22, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.CancelQText cancelQText = 24; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.cancelqtext_), _Internal::kOneofCaseOffset + 0, 23, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SetFPS setFPS = 25; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.setfps_), _Internal::kOneofCaseOffset + 0, 24, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.DisarmTrap disarmTrap = 26; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.disarmtrap_), _Internal::kOneofCaseOffset + 0, 25, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SkillRepair skillRepair = 27; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.skillrepair_), _Internal::kOneofCaseOffset + 0, 26, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SkillRecharge skillRecharge = 28; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.skillrecharge_), _Internal::kOneofCaseOffset + 0, 27, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.ToggleMenu toggleMenu = 29; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.togglemenu_), _Internal::kOneofCaseOffset + 0, 28, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.SaveGame saveGame = 30; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.savegame_), _Internal::kOneofCaseOffset + 0, 29, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.Quit quit = 31; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.quit_), _Internal::kOneofCaseOffset + 0, 30, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.ClearCursor clearCursor = 32; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.clearcursor_), _Internal::kOneofCaseOffset + 0, 31, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.IdentifyItem identifyItem = 33; + {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.identifyitem_), _Internal::kOneofCaseOffset + 0, 32, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::dapi::commands::Move>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::Talk>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SelectStoreOption>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::BuyItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SellItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::RechargeItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::RepairItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::AttackMonster>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::AttackXY>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::OperateObject>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::UseBeltItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::ToggleCharacterSheet>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::IncreaseStat>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::GetItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SetSpell>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::CastMonster>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::CastXY>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::ToggleInventory>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::PutInCursor>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::PutCursorItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::DropCursorItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::UseItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::IdentifyStoreItem>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::CancelQText>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SetFPS>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::DisarmTrap>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SkillRepair>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SkillRecharge>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::ToggleMenu>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::SaveGame>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::Quit>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::ClearCursor>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::IdentifyItem>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void Command::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.commands.Command) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_command(); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Command::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Command& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Command::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Command& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Command) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (this_.command_case()) { + case kMove: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.command_.move_, this_._impl_.command_.move_->GetCachedSize(), target, + stream); + break; + } + case kTalk: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.command_.talk_, this_._impl_.command_.talk_->GetCachedSize(), target, + stream); + break; + } + case kOption: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.command_.option_, this_._impl_.command_.option_->GetCachedSize(), target, + stream); + break; + } + case kBuyItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.command_.buyitem_, this_._impl_.command_.buyitem_->GetCachedSize(), target, + stream); + break; + } + case kSellItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.command_.sellitem_, this_._impl_.command_.sellitem_->GetCachedSize(), target, + stream); + break; + } + case kRechargeItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 6, *this_._impl_.command_.rechargeitem_, this_._impl_.command_.rechargeitem_->GetCachedSize(), target, + stream); + break; + } + case kRepairItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 7, *this_._impl_.command_.repairitem_, this_._impl_.command_.repairitem_->GetCachedSize(), target, + stream); + break; + } + case kAttackMonster: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 8, *this_._impl_.command_.attackmonster_, this_._impl_.command_.attackmonster_->GetCachedSize(), target, + stream); + break; + } + case kAttackXY: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 9, *this_._impl_.command_.attackxy_, this_._impl_.command_.attackxy_->GetCachedSize(), target, + stream); + break; + } + case kOperateObject: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 10, *this_._impl_.command_.operateobject_, this_._impl_.command_.operateobject_->GetCachedSize(), target, + stream); + break; + } + case kUseBeltItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 11, *this_._impl_.command_.usebeltitem_, this_._impl_.command_.usebeltitem_->GetCachedSize(), target, + stream); + break; + } + case kToggleCharacterSheet: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 12, *this_._impl_.command_.togglecharactersheet_, this_._impl_.command_.togglecharactersheet_->GetCachedSize(), target, + stream); + break; + } + case kIncreaseStat: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 13, *this_._impl_.command_.increasestat_, this_._impl_.command_.increasestat_->GetCachedSize(), target, + stream); + break; + } + case kGetItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 14, *this_._impl_.command_.getitem_, this_._impl_.command_.getitem_->GetCachedSize(), target, + stream); + break; + } + case kSetSpell: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 15, *this_._impl_.command_.setspell_, this_._impl_.command_.setspell_->GetCachedSize(), target, + stream); + break; + } + case kCastMonster: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 16, *this_._impl_.command_.castmonster_, this_._impl_.command_.castmonster_->GetCachedSize(), target, + stream); + break; + } + case kCastXY: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 17, *this_._impl_.command_.castxy_, this_._impl_.command_.castxy_->GetCachedSize(), target, + stream); + break; + } + case kToggleInventory: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 18, *this_._impl_.command_.toggleinventory_, this_._impl_.command_.toggleinventory_->GetCachedSize(), target, + stream); + break; + } + case kPutInCursor: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 19, *this_._impl_.command_.putincursor_, this_._impl_.command_.putincursor_->GetCachedSize(), target, + stream); + break; + } + case kPutCursorItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 20, *this_._impl_.command_.putcursoritem_, this_._impl_.command_.putcursoritem_->GetCachedSize(), target, + stream); + break; + } + case kDropCursorItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 21, *this_._impl_.command_.dropcursoritem_, this_._impl_.command_.dropcursoritem_->GetCachedSize(), target, + stream); + break; + } + case kUseItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 22, *this_._impl_.command_.useitem_, this_._impl_.command_.useitem_->GetCachedSize(), target, + stream); + break; + } + case kIdentifyStoreItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 23, *this_._impl_.command_.identifystoreitem_, this_._impl_.command_.identifystoreitem_->GetCachedSize(), target, + stream); + break; + } + case kCancelQText: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 24, *this_._impl_.command_.cancelqtext_, this_._impl_.command_.cancelqtext_->GetCachedSize(), target, + stream); + break; + } + case kSetFPS: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 25, *this_._impl_.command_.setfps_, this_._impl_.command_.setfps_->GetCachedSize(), target, + stream); + break; + } + case kDisarmTrap: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 26, *this_._impl_.command_.disarmtrap_, this_._impl_.command_.disarmtrap_->GetCachedSize(), target, + stream); + break; + } + case kSkillRepair: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 27, *this_._impl_.command_.skillrepair_, this_._impl_.command_.skillrepair_->GetCachedSize(), target, + stream); + break; + } + case kSkillRecharge: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 28, *this_._impl_.command_.skillrecharge_, this_._impl_.command_.skillrecharge_->GetCachedSize(), target, + stream); + break; + } + case kToggleMenu: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 29, *this_._impl_.command_.togglemenu_, this_._impl_.command_.togglemenu_->GetCachedSize(), target, + stream); + break; + } + case kSaveGame: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 30, *this_._impl_.command_.savegame_, this_._impl_.command_.savegame_->GetCachedSize(), target, + stream); + break; + } + case kQuit: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 31, *this_._impl_.command_.quit_, this_._impl_.command_.quit_->GetCachedSize(), target, + stream); + break; + } + case kClearCursor: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 32, *this_._impl_.command_.clearcursor_, this_._impl_.command_.clearcursor_->GetCachedSize(), target, + stream); + break; + } + case kIdentifyItem: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 33, *this_._impl_.command_.identifyitem_, this_._impl_.command_.identifyitem_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Command) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Command::ByteSizeLong(const MessageLite& base) { + const Command& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Command::ByteSizeLong() const { + const Command& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Command) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (this_.command_case()) { + // .dapi.commands.Move move = 1; + case kMove: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.move_); + break; + } + // .dapi.commands.Talk talk = 2; + case kTalk: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.talk_); + break; + } + // .dapi.commands.SelectStoreOption option = 3; + case kOption: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.option_); + break; + } + // .dapi.commands.BuyItem buyItem = 4; + case kBuyItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.buyitem_); + break; + } + // .dapi.commands.SellItem sellItem = 5; + case kSellItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.sellitem_); + break; + } + // .dapi.commands.RechargeItem rechargeItem = 6; + case kRechargeItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.rechargeitem_); + break; + } + // .dapi.commands.RepairItem repairItem = 7; + case kRepairItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.repairitem_); + break; + } + // .dapi.commands.AttackMonster attackMonster = 8; + case kAttackMonster: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.attackmonster_); + break; + } + // .dapi.commands.AttackXY attackXY = 9; + case kAttackXY: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.attackxy_); + break; + } + // .dapi.commands.OperateObject operateObject = 10; + case kOperateObject: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.operateobject_); + break; + } + // .dapi.commands.UseBeltItem useBeltItem = 11; + case kUseBeltItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.usebeltitem_); + break; + } + // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; + case kToggleCharacterSheet: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.togglecharactersheet_); + break; + } + // .dapi.commands.IncreaseStat increaseStat = 13; + case kIncreaseStat: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.increasestat_); + break; + } + // .dapi.commands.GetItem getItem = 14; + case kGetItem: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.getitem_); + break; + } + // .dapi.commands.SetSpell setSpell = 15; + case kSetSpell: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.setspell_); + break; + } + // .dapi.commands.CastMonster castMonster = 16; + case kCastMonster: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.castmonster_); + break; + } + // .dapi.commands.CastXY castXY = 17; + case kCastXY: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.castxy_); + break; + } + // .dapi.commands.ToggleInventory toggleInventory = 18; + case kToggleInventory: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.toggleinventory_); + break; + } + // .dapi.commands.PutInCursor putInCursor = 19; + case kPutInCursor: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.putincursor_); + break; + } + // .dapi.commands.PutCursorItem putCursorItem = 20; + case kPutCursorItem: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.putcursoritem_); + break; + } + // .dapi.commands.DropCursorItem dropCursorItem = 21; + case kDropCursorItem: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.dropcursoritem_); + break; + } + // .dapi.commands.UseItem useItem = 22; + case kUseItem: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.useitem_); + break; + } + // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; + case kIdentifyStoreItem: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.identifystoreitem_); + break; + } + // .dapi.commands.CancelQText cancelQText = 24; + case kCancelQText: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.cancelqtext_); + break; + } + // .dapi.commands.SetFPS setFPS = 25; + case kSetFPS: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.setfps_); + break; + } + // .dapi.commands.DisarmTrap disarmTrap = 26; + case kDisarmTrap: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.disarmtrap_); + break; + } + // .dapi.commands.SkillRepair skillRepair = 27; + case kSkillRepair: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.skillrepair_); + break; + } + // .dapi.commands.SkillRecharge skillRecharge = 28; + case kSkillRecharge: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.skillrecharge_); + break; + } + // .dapi.commands.ToggleMenu toggleMenu = 29; + case kToggleMenu: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.togglemenu_); + break; + } + // .dapi.commands.SaveGame saveGame = 30; + case kSaveGame: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.savegame_); + break; + } + // .dapi.commands.Quit quit = 31; + case kQuit: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.quit_); + break; + } + // .dapi.commands.ClearCursor clearCursor = 32; + case kClearCursor: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.clearcursor_); + break; + } + // .dapi.commands.IdentifyItem identifyItem = 33; + case kIdentifyItem: { + total_size += 2 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.identifyitem_); + break; + } + case COMMAND_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void Command::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Command) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_command(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kMove: { + if (oneof_needs_init) { + _this->_impl_.command_.move_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Move>(arena, *from._impl_.command_.move_); + } else { + _this->_impl_.command_.move_->MergeFrom(from._internal_move()); + } + break; + } + case kTalk: { + if (oneof_needs_init) { + _this->_impl_.command_.talk_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Talk>(arena, *from._impl_.command_.talk_); + } else { + _this->_impl_.command_.talk_->MergeFrom(from._internal_talk()); + } + break; + } + case kOption: { + if (oneof_needs_init) { + _this->_impl_.command_.option_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SelectStoreOption>(arena, *from._impl_.command_.option_); + } else { + _this->_impl_.command_.option_->MergeFrom(from._internal_option()); + } + break; + } + case kBuyItem: { + if (oneof_needs_init) { + _this->_impl_.command_.buyitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::BuyItem>(arena, *from._impl_.command_.buyitem_); + } else { + _this->_impl_.command_.buyitem_->MergeFrom(from._internal_buyitem()); + } + break; + } + case kSellItem: { + if (oneof_needs_init) { + _this->_impl_.command_.sellitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SellItem>(arena, *from._impl_.command_.sellitem_); + } else { + _this->_impl_.command_.sellitem_->MergeFrom(from._internal_sellitem()); + } + break; + } + case kRechargeItem: { + if (oneof_needs_init) { + _this->_impl_.command_.rechargeitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RechargeItem>(arena, *from._impl_.command_.rechargeitem_); + } else { + _this->_impl_.command_.rechargeitem_->MergeFrom(from._internal_rechargeitem()); + } + break; + } + case kRepairItem: { + if (oneof_needs_init) { + _this->_impl_.command_.repairitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RepairItem>(arena, *from._impl_.command_.repairitem_); + } else { + _this->_impl_.command_.repairitem_->MergeFrom(from._internal_repairitem()); + } + break; + } + case kAttackMonster: { + if (oneof_needs_init) { + _this->_impl_.command_.attackmonster_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackMonster>(arena, *from._impl_.command_.attackmonster_); + } else { + _this->_impl_.command_.attackmonster_->MergeFrom(from._internal_attackmonster()); + } + break; + } + case kAttackXY: { + if (oneof_needs_init) { + _this->_impl_.command_.attackxy_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackXY>(arena, *from._impl_.command_.attackxy_); + } else { + _this->_impl_.command_.attackxy_->MergeFrom(from._internal_attackxy()); + } + break; + } + case kOperateObject: { + if (oneof_needs_init) { + _this->_impl_.command_.operateobject_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::OperateObject>(arena, *from._impl_.command_.operateobject_); + } else { + _this->_impl_.command_.operateobject_->MergeFrom(from._internal_operateobject()); + } + break; + } + case kUseBeltItem: { + if (oneof_needs_init) { + _this->_impl_.command_.usebeltitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseBeltItem>(arena, *from._impl_.command_.usebeltitem_); + } else { + _this->_impl_.command_.usebeltitem_->MergeFrom(from._internal_usebeltitem()); + } + break; + } + case kToggleCharacterSheet: { + if (oneof_needs_init) { + _this->_impl_.command_.togglecharactersheet_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleCharacterSheet>(arena, *from._impl_.command_.togglecharactersheet_); + } else { + _this->_impl_.command_.togglecharactersheet_->MergeFrom(from._internal_togglecharactersheet()); + } + break; + } + case kIncreaseStat: { + if (oneof_needs_init) { + _this->_impl_.command_.increasestat_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IncreaseStat>(arena, *from._impl_.command_.increasestat_); + } else { + _this->_impl_.command_.increasestat_->MergeFrom(from._internal_increasestat()); + } + break; + } + case kGetItem: { + if (oneof_needs_init) { + _this->_impl_.command_.getitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::GetItem>(arena, *from._impl_.command_.getitem_); + } else { + _this->_impl_.command_.getitem_->MergeFrom(from._internal_getitem()); + } + break; + } + case kSetSpell: { + if (oneof_needs_init) { + _this->_impl_.command_.setspell_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetSpell>(arena, *from._impl_.command_.setspell_); + } else { + _this->_impl_.command_.setspell_->MergeFrom(from._internal_setspell()); + } + break; + } + case kCastMonster: { + if (oneof_needs_init) { + _this->_impl_.command_.castmonster_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastMonster>(arena, *from._impl_.command_.castmonster_); + } else { + _this->_impl_.command_.castmonster_->MergeFrom(from._internal_castmonster()); + } + break; + } + case kCastXY: { + if (oneof_needs_init) { + _this->_impl_.command_.castxy_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastXY>(arena, *from._impl_.command_.castxy_); + } else { + _this->_impl_.command_.castxy_->MergeFrom(from._internal_castxy()); + } + break; + } + case kToggleInventory: { + if (oneof_needs_init) { + _this->_impl_.command_.toggleinventory_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleInventory>(arena, *from._impl_.command_.toggleinventory_); + } else { + _this->_impl_.command_.toggleinventory_->MergeFrom(from._internal_toggleinventory()); + } + break; + } + case kPutInCursor: { + if (oneof_needs_init) { + _this->_impl_.command_.putincursor_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutInCursor>(arena, *from._impl_.command_.putincursor_); + } else { + _this->_impl_.command_.putincursor_->MergeFrom(from._internal_putincursor()); + } + break; + } + case kPutCursorItem: { + if (oneof_needs_init) { + _this->_impl_.command_.putcursoritem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutCursorItem>(arena, *from._impl_.command_.putcursoritem_); + } else { + _this->_impl_.command_.putcursoritem_->MergeFrom(from._internal_putcursoritem()); + } + break; + } + case kDropCursorItem: { + if (oneof_needs_init) { + _this->_impl_.command_.dropcursoritem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DropCursorItem>(arena, *from._impl_.command_.dropcursoritem_); + } else { + _this->_impl_.command_.dropcursoritem_->MergeFrom(from._internal_dropcursoritem()); + } + break; + } + case kUseItem: { + if (oneof_needs_init) { + _this->_impl_.command_.useitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseItem>(arena, *from._impl_.command_.useitem_); + } else { + _this->_impl_.command_.useitem_->MergeFrom(from._internal_useitem()); + } + break; + } + case kIdentifyStoreItem: { + if (oneof_needs_init) { + _this->_impl_.command_.identifystoreitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyStoreItem>(arena, *from._impl_.command_.identifystoreitem_); + } else { + _this->_impl_.command_.identifystoreitem_->MergeFrom(from._internal_identifystoreitem()); + } + break; + } + case kCancelQText: { + if (oneof_needs_init) { + _this->_impl_.command_.cancelqtext_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CancelQText>(arena, *from._impl_.command_.cancelqtext_); + } else { + _this->_impl_.command_.cancelqtext_->MergeFrom(from._internal_cancelqtext()); + } + break; + } + case kSetFPS: { + if (oneof_needs_init) { + _this->_impl_.command_.setfps_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetFPS>(arena, *from._impl_.command_.setfps_); + } else { + _this->_impl_.command_.setfps_->MergeFrom(from._internal_setfps()); + } + break; + } + case kDisarmTrap: { + if (oneof_needs_init) { + _this->_impl_.command_.disarmtrap_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DisarmTrap>(arena, *from._impl_.command_.disarmtrap_); + } else { + _this->_impl_.command_.disarmtrap_->MergeFrom(from._internal_disarmtrap()); + } + break; + } + case kSkillRepair: { + if (oneof_needs_init) { + _this->_impl_.command_.skillrepair_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRepair>(arena, *from._impl_.command_.skillrepair_); + } else { + _this->_impl_.command_.skillrepair_->MergeFrom(from._internal_skillrepair()); + } + break; + } + case kSkillRecharge: { + if (oneof_needs_init) { + _this->_impl_.command_.skillrecharge_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRecharge>(arena, *from._impl_.command_.skillrecharge_); + } else { + _this->_impl_.command_.skillrecharge_->MergeFrom(from._internal_skillrecharge()); + } + break; + } + case kToggleMenu: { + if (oneof_needs_init) { + _this->_impl_.command_.togglemenu_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleMenu>(arena, *from._impl_.command_.togglemenu_); + } else { + _this->_impl_.command_.togglemenu_->MergeFrom(from._internal_togglemenu()); + } + break; + } + case kSaveGame: { + if (oneof_needs_init) { + _this->_impl_.command_.savegame_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SaveGame>(arena, *from._impl_.command_.savegame_); + } else { + _this->_impl_.command_.savegame_->MergeFrom(from._internal_savegame()); + } + break; + } + case kQuit: { + if (oneof_needs_init) { + _this->_impl_.command_.quit_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Quit>(arena, *from._impl_.command_.quit_); + } else { + _this->_impl_.command_.quit_->MergeFrom(from._internal_quit()); + } + break; + } + case kClearCursor: { + if (oneof_needs_init) { + _this->_impl_.command_.clearcursor_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ClearCursor>(arena, *from._impl_.command_.clearcursor_); + } else { + _this->_impl_.command_.clearcursor_->MergeFrom(from._internal_clearcursor()); + } + break; + } + case kIdentifyItem: { + if (oneof_needs_init) { + _this->_impl_.command_.identifyitem_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyItem>(arena, *from._impl_.command_.identifyitem_); + } else { + _this->_impl_.command_.identifyitem_->MergeFrom(from._internal_identifyitem()); + } + break; + } + case COMMAND_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void Command::CopyFrom(const Command& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Command) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Command::InternalSwap(Command* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.command_, other->_impl_.command_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace commands +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/command.pb.h b/Source/dapi/Backend/Messages/generated/command.pb.h new file mode 100644 index 000000000..9038fe269 --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/command.pb.h @@ -0,0 +1,10429 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: command.proto +// Protobuf C++ Version: 5.29.3 + +#ifndef command_2eproto_2epb_2eh +#define command_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029003 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_command_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_command_2eproto { + static const ::uint32_t offsets[]; +}; +namespace dapi { +namespace commands { +class AttackMonster; +struct AttackMonsterDefaultTypeInternal; +extern AttackMonsterDefaultTypeInternal _AttackMonster_default_instance_; +class AttackXY; +struct AttackXYDefaultTypeInternal; +extern AttackXYDefaultTypeInternal _AttackXY_default_instance_; +class BuyItem; +struct BuyItemDefaultTypeInternal; +extern BuyItemDefaultTypeInternal _BuyItem_default_instance_; +class CancelQText; +struct CancelQTextDefaultTypeInternal; +extern CancelQTextDefaultTypeInternal _CancelQText_default_instance_; +class CastMonster; +struct CastMonsterDefaultTypeInternal; +extern CastMonsterDefaultTypeInternal _CastMonster_default_instance_; +class CastXY; +struct CastXYDefaultTypeInternal; +extern CastXYDefaultTypeInternal _CastXY_default_instance_; +class ClearCursor; +struct ClearCursorDefaultTypeInternal; +extern ClearCursorDefaultTypeInternal _ClearCursor_default_instance_; +class Command; +struct CommandDefaultTypeInternal; +extern CommandDefaultTypeInternal _Command_default_instance_; +class DisarmTrap; +struct DisarmTrapDefaultTypeInternal; +extern DisarmTrapDefaultTypeInternal _DisarmTrap_default_instance_; +class DropCursorItem; +struct DropCursorItemDefaultTypeInternal; +extern DropCursorItemDefaultTypeInternal _DropCursorItem_default_instance_; +class GetItem; +struct GetItemDefaultTypeInternal; +extern GetItemDefaultTypeInternal _GetItem_default_instance_; +class IdentifyItem; +struct IdentifyItemDefaultTypeInternal; +extern IdentifyItemDefaultTypeInternal _IdentifyItem_default_instance_; +class IdentifyStoreItem; +struct IdentifyStoreItemDefaultTypeInternal; +extern IdentifyStoreItemDefaultTypeInternal _IdentifyStoreItem_default_instance_; +class IncreaseStat; +struct IncreaseStatDefaultTypeInternal; +extern IncreaseStatDefaultTypeInternal _IncreaseStat_default_instance_; +class Move; +struct MoveDefaultTypeInternal; +extern MoveDefaultTypeInternal _Move_default_instance_; +class OperateObject; +struct OperateObjectDefaultTypeInternal; +extern OperateObjectDefaultTypeInternal _OperateObject_default_instance_; +class PutCursorItem; +struct PutCursorItemDefaultTypeInternal; +extern PutCursorItemDefaultTypeInternal _PutCursorItem_default_instance_; +class PutInCursor; +struct PutInCursorDefaultTypeInternal; +extern PutInCursorDefaultTypeInternal _PutInCursor_default_instance_; +class Quit; +struct QuitDefaultTypeInternal; +extern QuitDefaultTypeInternal _Quit_default_instance_; +class RechargeItem; +struct RechargeItemDefaultTypeInternal; +extern RechargeItemDefaultTypeInternal _RechargeItem_default_instance_; +class RepairItem; +struct RepairItemDefaultTypeInternal; +extern RepairItemDefaultTypeInternal _RepairItem_default_instance_; +class SaveGame; +struct SaveGameDefaultTypeInternal; +extern SaveGameDefaultTypeInternal _SaveGame_default_instance_; +class SelectStoreOption; +struct SelectStoreOptionDefaultTypeInternal; +extern SelectStoreOptionDefaultTypeInternal _SelectStoreOption_default_instance_; +class SellItem; +struct SellItemDefaultTypeInternal; +extern SellItemDefaultTypeInternal _SellItem_default_instance_; +class SetFPS; +struct SetFPSDefaultTypeInternal; +extern SetFPSDefaultTypeInternal _SetFPS_default_instance_; +class SetSpell; +struct SetSpellDefaultTypeInternal; +extern SetSpellDefaultTypeInternal _SetSpell_default_instance_; +class SkillRecharge; +struct SkillRechargeDefaultTypeInternal; +extern SkillRechargeDefaultTypeInternal _SkillRecharge_default_instance_; +class SkillRepair; +struct SkillRepairDefaultTypeInternal; +extern SkillRepairDefaultTypeInternal _SkillRepair_default_instance_; +class Talk; +struct TalkDefaultTypeInternal; +extern TalkDefaultTypeInternal _Talk_default_instance_; +class ToggleCharacterSheet; +struct ToggleCharacterSheetDefaultTypeInternal; +extern ToggleCharacterSheetDefaultTypeInternal _ToggleCharacterSheet_default_instance_; +class ToggleInventory; +struct ToggleInventoryDefaultTypeInternal; +extern ToggleInventoryDefaultTypeInternal _ToggleInventory_default_instance_; +class ToggleMenu; +struct ToggleMenuDefaultTypeInternal; +extern ToggleMenuDefaultTypeInternal _ToggleMenu_default_instance_; +class UseBeltItem; +struct UseBeltItemDefaultTypeInternal; +extern UseBeltItemDefaultTypeInternal _UseBeltItem_default_instance_; +class UseItem; +struct UseItemDefaultTypeInternal; +extern UseItemDefaultTypeInternal _UseItem_default_instance_; +} // namespace commands +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace dapi { +namespace commands { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class UseItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.UseItem) */ { + public: + inline UseItem() : UseItem(nullptr) {} + ~UseItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseItem( + ::google::protobuf::internal::ConstantInitialized); + + inline UseItem(const UseItem& from) : UseItem(nullptr, from) {} + inline UseItem(UseItem&& from) noexcept + : UseItem(nullptr, std::move(from)) {} + inline UseItem& operator=(const UseItem& from) { + CopyFrom(from); + return *this; + } + inline UseItem& operator=(UseItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const UseItem& default_instance() { + return *internal_default_instance(); + } + static inline const UseItem* internal_default_instance() { + return reinterpret_cast( + &_UseItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 23; + friend void swap(UseItem& a, UseItem& b) { a.Swap(&b); } + inline void Swap(UseItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const UseItem& from); + void MergeFrom(const UseItem& from) { UseItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UseItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.UseItem"; } + + protected: + explicit UseItem(::google::protobuf::Arena* arena); + UseItem(::google::protobuf::Arena* arena, const UseItem& from); + UseItem(::google::protobuf::Arena* arena, UseItem&& from) noexcept + : UseItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.UseItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class UseBeltItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.UseBeltItem) */ { + public: + inline UseBeltItem() : UseBeltItem(nullptr) {} + ~UseBeltItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(UseBeltItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(UseBeltItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR UseBeltItem( + ::google::protobuf::internal::ConstantInitialized); + + inline UseBeltItem(const UseBeltItem& from) : UseBeltItem(nullptr, from) {} + inline UseBeltItem(UseBeltItem&& from) noexcept + : UseBeltItem(nullptr, std::move(from)) {} + inline UseBeltItem& operator=(const UseBeltItem& from) { + CopyFrom(from); + return *this; + } + inline UseBeltItem& operator=(UseBeltItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const UseBeltItem& default_instance() { + return *internal_default_instance(); + } + static inline const UseBeltItem* internal_default_instance() { + return reinterpret_cast( + &_UseBeltItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 12; + friend void swap(UseBeltItem& a, UseBeltItem& b) { a.Swap(&b); } + inline void Swap(UseBeltItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(UseBeltItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + UseBeltItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const UseBeltItem& from); + void MergeFrom(const UseBeltItem& from) { UseBeltItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(UseBeltItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.UseBeltItem"; } + + protected: + explicit UseBeltItem(::google::protobuf::Arena* arena); + UseBeltItem(::google::protobuf::Arena* arena, const UseBeltItem& from); + UseBeltItem(::google::protobuf::Arena* arena, UseBeltItem&& from) noexcept + : UseBeltItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSlotFieldNumber = 1, + }; + // uint32 slot = 1; + void clear_slot() ; + ::uint32_t slot() const; + void set_slot(::uint32_t value); + + private: + ::uint32_t _internal_slot() const; + void _internal_set_slot(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.UseBeltItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const UseBeltItem& from_msg); + ::uint32_t slot_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class ToggleMenu final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleMenu) */ { + public: + inline ToggleMenu() : ToggleMenu(nullptr) {} + ~ToggleMenu() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ToggleMenu* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleMenu)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ToggleMenu( + ::google::protobuf::internal::ConstantInitialized); + + inline ToggleMenu(const ToggleMenu& from) : ToggleMenu(nullptr, from) {} + inline ToggleMenu(ToggleMenu&& from) noexcept + : ToggleMenu(nullptr, std::move(from)) {} + inline ToggleMenu& operator=(const ToggleMenu& from) { + CopyFrom(from); + return *this; + } + inline ToggleMenu& operator=(ToggleMenu&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ToggleMenu& default_instance() { + return *internal_default_instance(); + } + static inline const ToggleMenu* internal_default_instance() { + return reinterpret_cast( + &_ToggleMenu_default_instance_); + } + static constexpr int kIndexInFileMessages = 28; + friend void swap(ToggleMenu& a, ToggleMenu& b) { a.Swap(&b); } + inline void Swap(ToggleMenu* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ToggleMenu* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ToggleMenu* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ToggleMenu& from); + void MergeFrom(const ToggleMenu& from) { ToggleMenu::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ToggleMenu* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleMenu"; } + + protected: + explicit ToggleMenu(::google::protobuf::Arena* arena); + ToggleMenu(::google::protobuf::Arena* arena, const ToggleMenu& from); + ToggleMenu(::google::protobuf::Arena* arena, ToggleMenu&& from) noexcept + : ToggleMenu(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.ToggleMenu) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ToggleMenu& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class ToggleInventory final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleInventory) */ { + public: + inline ToggleInventory() : ToggleInventory(nullptr) {} + ~ToggleInventory() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ToggleInventory* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleInventory)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ToggleInventory( + ::google::protobuf::internal::ConstantInitialized); + + inline ToggleInventory(const ToggleInventory& from) : ToggleInventory(nullptr, from) {} + inline ToggleInventory(ToggleInventory&& from) noexcept + : ToggleInventory(nullptr, std::move(from)) {} + inline ToggleInventory& operator=(const ToggleInventory& from) { + CopyFrom(from); + return *this; + } + inline ToggleInventory& operator=(ToggleInventory&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ToggleInventory& default_instance() { + return *internal_default_instance(); + } + static inline const ToggleInventory* internal_default_instance() { + return reinterpret_cast( + &_ToggleInventory_default_instance_); + } + static constexpr int kIndexInFileMessages = 19; + friend void swap(ToggleInventory& a, ToggleInventory& b) { a.Swap(&b); } + inline void Swap(ToggleInventory* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ToggleInventory* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ToggleInventory* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ToggleInventory& from); + void MergeFrom(const ToggleInventory& from) { ToggleInventory::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ToggleInventory* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleInventory"; } + + protected: + explicit ToggleInventory(::google::protobuf::Arena* arena); + ToggleInventory(::google::protobuf::Arena* arena, const ToggleInventory& from); + ToggleInventory(::google::protobuf::Arena* arena, ToggleInventory&& from) noexcept + : ToggleInventory(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<30> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.ToggleInventory) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ToggleInventory& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class ToggleCharacterSheet final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleCharacterSheet) */ { + public: + inline ToggleCharacterSheet() : ToggleCharacterSheet(nullptr) {} + ~ToggleCharacterSheet() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ToggleCharacterSheet* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleCharacterSheet)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ToggleCharacterSheet( + ::google::protobuf::internal::ConstantInitialized); + + inline ToggleCharacterSheet(const ToggleCharacterSheet& from) : ToggleCharacterSheet(nullptr, from) {} + inline ToggleCharacterSheet(ToggleCharacterSheet&& from) noexcept + : ToggleCharacterSheet(nullptr, std::move(from)) {} + inline ToggleCharacterSheet& operator=(const ToggleCharacterSheet& from) { + CopyFrom(from); + return *this; + } + inline ToggleCharacterSheet& operator=(ToggleCharacterSheet&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ToggleCharacterSheet& default_instance() { + return *internal_default_instance(); + } + static inline const ToggleCharacterSheet* internal_default_instance() { + return reinterpret_cast( + &_ToggleCharacterSheet_default_instance_); + } + static constexpr int kIndexInFileMessages = 13; + friend void swap(ToggleCharacterSheet& a, ToggleCharacterSheet& b) { a.Swap(&b); } + inline void Swap(ToggleCharacterSheet* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ToggleCharacterSheet* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ToggleCharacterSheet* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ToggleCharacterSheet& from); + void MergeFrom(const ToggleCharacterSheet& from) { ToggleCharacterSheet::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ToggleCharacterSheet* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleCharacterSheet"; } + + protected: + explicit ToggleCharacterSheet(::google::protobuf::Arena* arena); + ToggleCharacterSheet(::google::protobuf::Arena* arena, const ToggleCharacterSheet& from); + ToggleCharacterSheet(::google::protobuf::Arena* arena, ToggleCharacterSheet&& from) noexcept + : ToggleCharacterSheet(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<35> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.ToggleCharacterSheet) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ToggleCharacterSheet& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class Talk final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.Talk) */ { + public: + inline Talk() : Talk(nullptr) {} + ~Talk() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Talk* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Talk)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Talk( + ::google::protobuf::internal::ConstantInitialized); + + inline Talk(const Talk& from) : Talk(nullptr, from) {} + inline Talk(Talk&& from) noexcept + : Talk(nullptr, std::move(from)) {} + inline Talk& operator=(const Talk& from) { + CopyFrom(from); + return *this; + } + inline Talk& operator=(Talk&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const Talk& default_instance() { + return *internal_default_instance(); + } + static inline const Talk* internal_default_instance() { + return reinterpret_cast( + &_Talk_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(Talk& a, Talk& b) { a.Swap(&b); } + inline void Swap(Talk* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Talk* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Talk* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const Talk& from); + void MergeFrom(const Talk& from) { Talk::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Talk* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.Talk"; } + + protected: + explicit Talk(::google::protobuf::Arena* arena); + Talk(::google::protobuf::Arena* arena, const Talk& from); + Talk(::google::protobuf::Arena* arena, Talk&& from) noexcept + : Talk(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTargetXFieldNumber = 1, + kTargetYFieldNumber = 2, + }; + // uint32 targetX = 1; + void clear_targetx() ; + ::uint32_t targetx() const; + void set_targetx(::uint32_t value); + + private: + ::uint32_t _internal_targetx() const; + void _internal_set_targetx(::uint32_t value); + + public: + // uint32 targetY = 2; + void clear_targety() ; + ::uint32_t targety() const; + void set_targety(::uint32_t value); + + private: + ::uint32_t _internal_targety() const; + void _internal_set_targety(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.Talk) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Talk& from_msg); + ::uint32_t targetx_; + ::uint32_t targety_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SkillRepair final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SkillRepair) */ { + public: + inline SkillRepair() : SkillRepair(nullptr) {} + ~SkillRepair() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SkillRepair* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SkillRepair)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SkillRepair( + ::google::protobuf::internal::ConstantInitialized); + + inline SkillRepair(const SkillRepair& from) : SkillRepair(nullptr, from) {} + inline SkillRepair(SkillRepair&& from) noexcept + : SkillRepair(nullptr, std::move(from)) {} + inline SkillRepair& operator=(const SkillRepair& from) { + CopyFrom(from); + return *this; + } + inline SkillRepair& operator=(SkillRepair&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SkillRepair& default_instance() { + return *internal_default_instance(); + } + static inline const SkillRepair* internal_default_instance() { + return reinterpret_cast( + &_SkillRepair_default_instance_); + } + static constexpr int kIndexInFileMessages = 26; + friend void swap(SkillRepair& a, SkillRepair& b) { a.Swap(&b); } + inline void Swap(SkillRepair* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SkillRepair* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SkillRepair* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SkillRepair& from); + void MergeFrom(const SkillRepair& from) { SkillRepair::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SkillRepair* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SkillRepair"; } + + protected: + explicit SkillRepair(::google::protobuf::Arena* arena); + SkillRepair(::google::protobuf::Arena* arena, const SkillRepair& from); + SkillRepair(::google::protobuf::Arena* arena, SkillRepair&& from) noexcept + : SkillRepair(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.SkillRepair) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SkillRepair& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SkillRecharge final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SkillRecharge) */ { + public: + inline SkillRecharge() : SkillRecharge(nullptr) {} + ~SkillRecharge() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SkillRecharge* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SkillRecharge)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SkillRecharge( + ::google::protobuf::internal::ConstantInitialized); + + inline SkillRecharge(const SkillRecharge& from) : SkillRecharge(nullptr, from) {} + inline SkillRecharge(SkillRecharge&& from) noexcept + : SkillRecharge(nullptr, std::move(from)) {} + inline SkillRecharge& operator=(const SkillRecharge& from) { + CopyFrom(from); + return *this; + } + inline SkillRecharge& operator=(SkillRecharge&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SkillRecharge& default_instance() { + return *internal_default_instance(); + } + static inline const SkillRecharge* internal_default_instance() { + return reinterpret_cast( + &_SkillRecharge_default_instance_); + } + static constexpr int kIndexInFileMessages = 27; + friend void swap(SkillRecharge& a, SkillRecharge& b) { a.Swap(&b); } + inline void Swap(SkillRecharge* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SkillRecharge* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SkillRecharge* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SkillRecharge& from); + void MergeFrom(const SkillRecharge& from) { SkillRecharge::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SkillRecharge* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SkillRecharge"; } + + protected: + explicit SkillRecharge(::google::protobuf::Arena* arena); + SkillRecharge(::google::protobuf::Arena* arena, const SkillRecharge& from); + SkillRecharge(::google::protobuf::Arena* arena, SkillRecharge&& from) noexcept + : SkillRecharge(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.SkillRecharge) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SkillRecharge& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SetSpell final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SetSpell) */ { + public: + inline SetSpell() : SetSpell(nullptr) {} + ~SetSpell() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetSpell* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetSpell)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetSpell( + ::google::protobuf::internal::ConstantInitialized); + + inline SetSpell(const SetSpell& from) : SetSpell(nullptr, from) {} + inline SetSpell(SetSpell&& from) noexcept + : SetSpell(nullptr, std::move(from)) {} + inline SetSpell& operator=(const SetSpell& from) { + CopyFrom(from); + return *this; + } + inline SetSpell& operator=(SetSpell&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SetSpell& default_instance() { + return *internal_default_instance(); + } + static inline const SetSpell* internal_default_instance() { + return reinterpret_cast( + &_SetSpell_default_instance_); + } + static constexpr int kIndexInFileMessages = 16; + friend void swap(SetSpell& a, SetSpell& b) { a.Swap(&b); } + inline void Swap(SetSpell* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetSpell* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetSpell* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SetSpell& from); + void MergeFrom(const SetSpell& from) { SetSpell::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetSpell* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SetSpell"; } + + protected: + explicit SetSpell(::google::protobuf::Arena* arena); + SetSpell(::google::protobuf::Arena* arena, const SetSpell& from); + SetSpell(::google::protobuf::Arena* arena, SetSpell&& from) noexcept + : SetSpell(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kSpellIDFieldNumber = 1, + kSpellTypeFieldNumber = 2, + }; + // sint32 spellID = 1; + void clear_spellid() ; + ::int32_t spellid() const; + void set_spellid(::int32_t value); + + private: + ::int32_t _internal_spellid() const; + void _internal_set_spellid(::int32_t value); + + public: + // sint32 spellType = 2; + void clear_spelltype() ; + ::int32_t spelltype() const; + void set_spelltype(::int32_t value); + + private: + ::int32_t _internal_spelltype() const; + void _internal_set_spelltype(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.SetSpell) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetSpell& from_msg); + ::int32_t spellid_; + ::int32_t spelltype_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SetFPS final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SetFPS) */ { + public: + inline SetFPS() : SetFPS(nullptr) {} + ~SetFPS() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SetFPS* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFPS)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SetFPS( + ::google::protobuf::internal::ConstantInitialized); + + inline SetFPS(const SetFPS& from) : SetFPS(nullptr, from) {} + inline SetFPS(SetFPS&& from) noexcept + : SetFPS(nullptr, std::move(from)) {} + inline SetFPS& operator=(const SetFPS& from) { + CopyFrom(from); + return *this; + } + inline SetFPS& operator=(SetFPS&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SetFPS& default_instance() { + return *internal_default_instance(); + } + static inline const SetFPS* internal_default_instance() { + return reinterpret_cast( + &_SetFPS_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(SetFPS& a, SetFPS& b) { a.Swap(&b); } + inline void Swap(SetFPS* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SetFPS* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SetFPS* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SetFPS& from); + void MergeFrom(const SetFPS& from) { SetFPS::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SetFPS* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SetFPS"; } + + protected: + explicit SetFPS(::google::protobuf::Arena* arena); + SetFPS(::google::protobuf::Arena* arena, const SetFPS& from); + SetFPS(::google::protobuf::Arena* arena, SetFPS&& from) noexcept + : SetFPS(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kFPSFieldNumber = 1, + }; + // uint32 FPS = 1; + void clear_fps() ; + ::uint32_t fps() const; + void set_fps(::uint32_t value); + + private: + ::uint32_t _internal_fps() const; + void _internal_set_fps(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.SetFPS) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SetFPS& from_msg); + ::uint32_t fps_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SellItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SellItem) */ { + public: + inline SellItem() : SellItem(nullptr) {} + ~SellItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SellItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SellItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SellItem( + ::google::protobuf::internal::ConstantInitialized); + + inline SellItem(const SellItem& from) : SellItem(nullptr, from) {} + inline SellItem(SellItem&& from) noexcept + : SellItem(nullptr, std::move(from)) {} + inline SellItem& operator=(const SellItem& from) { + CopyFrom(from); + return *this; + } + inline SellItem& operator=(SellItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SellItem& default_instance() { + return *internal_default_instance(); + } + static inline const SellItem* internal_default_instance() { + return reinterpret_cast( + &_SellItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(SellItem& a, SellItem& b) { a.Swap(&b); } + inline void Swap(SellItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SellItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SellItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SellItem& from); + void MergeFrom(const SellItem& from) { SellItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SellItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SellItem"; } + + protected: + explicit SellItem(::google::protobuf::Arena* arena); + SellItem(::google::protobuf::Arena* arena, const SellItem& from); + SellItem(::google::protobuf::Arena* arena, SellItem&& from) noexcept + : SellItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.SellItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SellItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SelectStoreOption final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SelectStoreOption) */ { + public: + inline SelectStoreOption() : SelectStoreOption(nullptr) {} + ~SelectStoreOption() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SelectStoreOption* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SelectStoreOption)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SelectStoreOption( + ::google::protobuf::internal::ConstantInitialized); + + inline SelectStoreOption(const SelectStoreOption& from) : SelectStoreOption(nullptr, from) {} + inline SelectStoreOption(SelectStoreOption&& from) noexcept + : SelectStoreOption(nullptr, std::move(from)) {} + inline SelectStoreOption& operator=(const SelectStoreOption& from) { + CopyFrom(from); + return *this; + } + inline SelectStoreOption& operator=(SelectStoreOption&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SelectStoreOption& default_instance() { + return *internal_default_instance(); + } + static inline const SelectStoreOption* internal_default_instance() { + return reinterpret_cast( + &_SelectStoreOption_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(SelectStoreOption& a, SelectStoreOption& b) { a.Swap(&b); } + inline void Swap(SelectStoreOption* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SelectStoreOption* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SelectStoreOption* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SelectStoreOption& from); + void MergeFrom(const SelectStoreOption& from) { SelectStoreOption::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SelectStoreOption* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SelectStoreOption"; } + + protected: + explicit SelectStoreOption(::google::protobuf::Arena* arena); + SelectStoreOption(::google::protobuf::Arena* arena, const SelectStoreOption& from); + SelectStoreOption(::google::protobuf::Arena* arena, SelectStoreOption&& from) noexcept + : SelectStoreOption(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<32> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kOptionFieldNumber = 1, + }; + // uint32 option = 1; + void clear_option() ; + ::uint32_t option() const; + void set_option(::uint32_t value); + + private: + ::uint32_t _internal_option() const; + void _internal_set_option(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.SelectStoreOption) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SelectStoreOption& from_msg); + ::uint32_t option_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class SaveGame final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.SaveGame) */ { + public: + inline SaveGame() : SaveGame(nullptr) {} + ~SaveGame() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(SaveGame* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(SaveGame)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR SaveGame( + ::google::protobuf::internal::ConstantInitialized); + + inline SaveGame(const SaveGame& from) : SaveGame(nullptr, from) {} + inline SaveGame(SaveGame&& from) noexcept + : SaveGame(nullptr, std::move(from)) {} + inline SaveGame& operator=(const SaveGame& from) { + CopyFrom(from); + return *this; + } + inline SaveGame& operator=(SaveGame&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const SaveGame& default_instance() { + return *internal_default_instance(); + } + static inline const SaveGame* internal_default_instance() { + return reinterpret_cast( + &_SaveGame_default_instance_); + } + static constexpr int kIndexInFileMessages = 29; + friend void swap(SaveGame& a, SaveGame& b) { a.Swap(&b); } + inline void Swap(SaveGame* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(SaveGame* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + SaveGame* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const SaveGame& from); + void MergeFrom(const SaveGame& from) { SaveGame::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(SaveGame* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.SaveGame"; } + + protected: + explicit SaveGame(::google::protobuf::Arena* arena); + SaveGame(::google::protobuf::Arena* arena, const SaveGame& from); + SaveGame(::google::protobuf::Arena* arena, SaveGame&& from) noexcept + : SaveGame(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.SaveGame) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const SaveGame& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class RepairItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.RepairItem) */ { + public: + inline RepairItem() : RepairItem(nullptr) {} + ~RepairItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RepairItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RepairItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RepairItem( + ::google::protobuf::internal::ConstantInitialized); + + inline RepairItem(const RepairItem& from) : RepairItem(nullptr, from) {} + inline RepairItem(RepairItem&& from) noexcept + : RepairItem(nullptr, std::move(from)) {} + inline RepairItem& operator=(const RepairItem& from) { + CopyFrom(from); + return *this; + } + inline RepairItem& operator=(RepairItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const RepairItem& default_instance() { + return *internal_default_instance(); + } + static inline const RepairItem* internal_default_instance() { + return reinterpret_cast( + &_RepairItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(RepairItem& a, RepairItem& b) { a.Swap(&b); } + inline void Swap(RepairItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RepairItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RepairItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const RepairItem& from); + void MergeFrom(const RepairItem& from) { RepairItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RepairItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.RepairItem"; } + + protected: + explicit RepairItem(::google::protobuf::Arena* arena); + RepairItem(::google::protobuf::Arena* arena, const RepairItem& from); + RepairItem(::google::protobuf::Arena* arena, RepairItem&& from) noexcept + : RepairItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.RepairItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RepairItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class RechargeItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.RechargeItem) */ { + public: + inline RechargeItem() : RechargeItem(nullptr) {} + ~RechargeItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(RechargeItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(RechargeItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR RechargeItem( + ::google::protobuf::internal::ConstantInitialized); + + inline RechargeItem(const RechargeItem& from) : RechargeItem(nullptr, from) {} + inline RechargeItem(RechargeItem&& from) noexcept + : RechargeItem(nullptr, std::move(from)) {} + inline RechargeItem& operator=(const RechargeItem& from) { + CopyFrom(from); + return *this; + } + inline RechargeItem& operator=(RechargeItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const RechargeItem& default_instance() { + return *internal_default_instance(); + } + static inline const RechargeItem* internal_default_instance() { + return reinterpret_cast( + &_RechargeItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + friend void swap(RechargeItem& a, RechargeItem& b) { a.Swap(&b); } + inline void Swap(RechargeItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(RechargeItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + RechargeItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const RechargeItem& from); + void MergeFrom(const RechargeItem& from) { RechargeItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(RechargeItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.RechargeItem"; } + + protected: + explicit RechargeItem(::google::protobuf::Arena* arena); + RechargeItem(::google::protobuf::Arena* arena, const RechargeItem& from); + RechargeItem(::google::protobuf::Arena* arena, RechargeItem&& from) noexcept + : RechargeItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.RechargeItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const RechargeItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class Quit final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.Quit) */ { + public: + inline Quit() : Quit(nullptr) {} + ~Quit() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Quit* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Quit)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Quit( + ::google::protobuf::internal::ConstantInitialized); + + inline Quit(const Quit& from) : Quit(nullptr, from) {} + inline Quit(Quit&& from) noexcept + : Quit(nullptr, std::move(from)) {} + inline Quit& operator=(const Quit& from) { + CopyFrom(from); + return *this; + } + inline Quit& operator=(Quit&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const Quit& default_instance() { + return *internal_default_instance(); + } + static inline const Quit* internal_default_instance() { + return reinterpret_cast( + &_Quit_default_instance_); + } + static constexpr int kIndexInFileMessages = 30; + friend void swap(Quit& a, Quit& b) { a.Swap(&b); } + inline void Swap(Quit* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Quit* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Quit* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const Quit& from); + void MergeFrom(const Quit& from) { Quit::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Quit* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.Quit"; } + + protected: + explicit Quit(::google::protobuf::Arena* arena); + Quit(::google::protobuf::Arena* arena, const Quit& from); + Quit(::google::protobuf::Arena* arena, Quit&& from) noexcept + : Quit(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.Quit) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Quit& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class PutInCursor final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.PutInCursor) */ { + public: + inline PutInCursor() : PutInCursor(nullptr) {} + ~PutInCursor() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PutInCursor* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PutInCursor)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PutInCursor( + ::google::protobuf::internal::ConstantInitialized); + + inline PutInCursor(const PutInCursor& from) : PutInCursor(nullptr, from) {} + inline PutInCursor(PutInCursor&& from) noexcept + : PutInCursor(nullptr, std::move(from)) {} + inline PutInCursor& operator=(const PutInCursor& from) { + CopyFrom(from); + return *this; + } + inline PutInCursor& operator=(PutInCursor&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PutInCursor& default_instance() { + return *internal_default_instance(); + } + static inline const PutInCursor* internal_default_instance() { + return reinterpret_cast( + &_PutInCursor_default_instance_); + } + static constexpr int kIndexInFileMessages = 20; + friend void swap(PutInCursor& a, PutInCursor& b) { a.Swap(&b); } + inline void Swap(PutInCursor* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PutInCursor* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PutInCursor* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const PutInCursor& from); + void MergeFrom(const PutInCursor& from) { PutInCursor::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PutInCursor* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.PutInCursor"; } + + protected: + explicit PutInCursor(::google::protobuf::Arena* arena); + PutInCursor(::google::protobuf::Arena* arena, const PutInCursor& from); + PutInCursor(::google::protobuf::Arena* arena, PutInCursor&& from) noexcept + : PutInCursor(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.PutInCursor) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PutInCursor& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class PutCursorItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.PutCursorItem) */ { + public: + inline PutCursorItem() : PutCursorItem(nullptr) {} + ~PutCursorItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PutCursorItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PutCursorItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PutCursorItem( + ::google::protobuf::internal::ConstantInitialized); + + inline PutCursorItem(const PutCursorItem& from) : PutCursorItem(nullptr, from) {} + inline PutCursorItem(PutCursorItem&& from) noexcept + : PutCursorItem(nullptr, std::move(from)) {} + inline PutCursorItem& operator=(const PutCursorItem& from) { + CopyFrom(from); + return *this; + } + inline PutCursorItem& operator=(PutCursorItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PutCursorItem& default_instance() { + return *internal_default_instance(); + } + static inline const PutCursorItem* internal_default_instance() { + return reinterpret_cast( + &_PutCursorItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 21; + friend void swap(PutCursorItem& a, PutCursorItem& b) { a.Swap(&b); } + inline void Swap(PutCursorItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PutCursorItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PutCursorItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const PutCursorItem& from); + void MergeFrom(const PutCursorItem& from) { PutCursorItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PutCursorItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.PutCursorItem"; } + + protected: + explicit PutCursorItem(::google::protobuf::Arena* arena); + PutCursorItem(::google::protobuf::Arena* arena, const PutCursorItem& from); + PutCursorItem(::google::protobuf::Arena* arena, PutCursorItem&& from) noexcept + : PutCursorItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTargetFieldNumber = 1, + }; + // sint32 target = 1; + void clear_target() ; + ::int32_t target() const; + void set_target(::int32_t value); + + private: + ::int32_t _internal_target() const; + void _internal_set_target(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.PutCursorItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PutCursorItem& from_msg); + ::int32_t target_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class OperateObject final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.OperateObject) */ { + public: + inline OperateObject() : OperateObject(nullptr) {} + ~OperateObject() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(OperateObject* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(OperateObject)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR OperateObject( + ::google::protobuf::internal::ConstantInitialized); + + inline OperateObject(const OperateObject& from) : OperateObject(nullptr, from) {} + inline OperateObject(OperateObject&& from) noexcept + : OperateObject(nullptr, std::move(from)) {} + inline OperateObject& operator=(const OperateObject& from) { + CopyFrom(from); + return *this; + } + inline OperateObject& operator=(OperateObject&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const OperateObject& default_instance() { + return *internal_default_instance(); + } + static inline const OperateObject* internal_default_instance() { + return reinterpret_cast( + &_OperateObject_default_instance_); + } + static constexpr int kIndexInFileMessages = 11; + friend void swap(OperateObject& a, OperateObject& b) { a.Swap(&b); } + inline void Swap(OperateObject* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(OperateObject* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + OperateObject* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const OperateObject& from); + void MergeFrom(const OperateObject& from) { OperateObject::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(OperateObject* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.OperateObject"; } + + protected: + explicit OperateObject(::google::protobuf::Arena* arena); + OperateObject(::google::protobuf::Arena* arena, const OperateObject& from); + OperateObject(::google::protobuf::Arena* arena, OperateObject&& from) noexcept + : OperateObject(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIndexFieldNumber = 1, + }; + // uint32 index = 1; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.OperateObject) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const OperateObject& from_msg); + ::uint32_t index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class Move final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.Move) */ { + public: + inline Move() : Move(nullptr) {} + ~Move() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Move* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Move)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Move( + ::google::protobuf::internal::ConstantInitialized); + + inline Move(const Move& from) : Move(nullptr, from) {} + inline Move(Move&& from) noexcept + : Move(nullptr, std::move(from)) {} + inline Move& operator=(const Move& from) { + CopyFrom(from); + return *this; + } + inline Move& operator=(Move&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const Move& default_instance() { + return *internal_default_instance(); + } + static inline const Move* internal_default_instance() { + return reinterpret_cast( + &_Move_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(Move& a, Move& b) { a.Swap(&b); } + inline void Swap(Move* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Move* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Move* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const Move& from); + void MergeFrom(const Move& from) { Move::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Move* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.Move"; } + + protected: + explicit Move(::google::protobuf::Arena* arena); + Move(::google::protobuf::Arena* arena, const Move& from); + Move(::google::protobuf::Arena* arena, Move&& from) noexcept + : Move(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTypeFieldNumber = 1, + kTargetXFieldNumber = 2, + kTargetYFieldNumber = 3, + }; + // uint32 type = 1; + void clear_type() ; + ::uint32_t type() const; + void set_type(::uint32_t value); + + private: + ::uint32_t _internal_type() const; + void _internal_set_type(::uint32_t value); + + public: + // uint32 targetX = 2; + void clear_targetx() ; + ::uint32_t targetx() const; + void set_targetx(::uint32_t value); + + private: + ::uint32_t _internal_targetx() const; + void _internal_set_targetx(::uint32_t value); + + public: + // uint32 targetY = 3; + void clear_targety() ; + ::uint32_t targety() const; + void set_targety(::uint32_t value); + + private: + ::uint32_t _internal_targety() const; + void _internal_set_targety(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.Move) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Move& from_msg); + ::uint32_t type_; + ::uint32_t targetx_; + ::uint32_t targety_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class IncreaseStat final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.IncreaseStat) */ { + public: + inline IncreaseStat() : IncreaseStat(nullptr) {} + ~IncreaseStat() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IncreaseStat* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IncreaseStat)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR IncreaseStat( + ::google::protobuf::internal::ConstantInitialized); + + inline IncreaseStat(const IncreaseStat& from) : IncreaseStat(nullptr, from) {} + inline IncreaseStat(IncreaseStat&& from) noexcept + : IncreaseStat(nullptr, std::move(from)) {} + inline IncreaseStat& operator=(const IncreaseStat& from) { + CopyFrom(from); + return *this; + } + inline IncreaseStat& operator=(IncreaseStat&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const IncreaseStat& default_instance() { + return *internal_default_instance(); + } + static inline const IncreaseStat* internal_default_instance() { + return reinterpret_cast( + &_IncreaseStat_default_instance_); + } + static constexpr int kIndexInFileMessages = 14; + friend void swap(IncreaseStat& a, IncreaseStat& b) { a.Swap(&b); } + inline void Swap(IncreaseStat* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IncreaseStat* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IncreaseStat* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const IncreaseStat& from); + void MergeFrom(const IncreaseStat& from) { IncreaseStat::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IncreaseStat* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.IncreaseStat"; } + + protected: + explicit IncreaseStat(::google::protobuf::Arena* arena); + IncreaseStat(::google::protobuf::Arena* arena, const IncreaseStat& from); + IncreaseStat(::google::protobuf::Arena* arena, IncreaseStat&& from) noexcept + : IncreaseStat(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kStatFieldNumber = 1, + }; + // uint32 stat = 1; + void clear_stat() ; + ::uint32_t stat() const; + void set_stat(::uint32_t value); + + private: + ::uint32_t _internal_stat() const; + void _internal_set_stat(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.IncreaseStat) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const IncreaseStat& from_msg); + ::uint32_t stat_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class IdentifyStoreItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.IdentifyStoreItem) */ { + public: + inline IdentifyStoreItem() : IdentifyStoreItem(nullptr) {} + ~IdentifyStoreItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IdentifyStoreItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IdentifyStoreItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR IdentifyStoreItem( + ::google::protobuf::internal::ConstantInitialized); + + inline IdentifyStoreItem(const IdentifyStoreItem& from) : IdentifyStoreItem(nullptr, from) {} + inline IdentifyStoreItem(IdentifyStoreItem&& from) noexcept + : IdentifyStoreItem(nullptr, std::move(from)) {} + inline IdentifyStoreItem& operator=(const IdentifyStoreItem& from) { + CopyFrom(from); + return *this; + } + inline IdentifyStoreItem& operator=(IdentifyStoreItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const IdentifyStoreItem& default_instance() { + return *internal_default_instance(); + } + static inline const IdentifyStoreItem* internal_default_instance() { + return reinterpret_cast( + &_IdentifyStoreItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 24; + friend void swap(IdentifyStoreItem& a, IdentifyStoreItem& b) { a.Swap(&b); } + inline void Swap(IdentifyStoreItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IdentifyStoreItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IdentifyStoreItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const IdentifyStoreItem& from); + void MergeFrom(const IdentifyStoreItem& from) { IdentifyStoreItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IdentifyStoreItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.IdentifyStoreItem"; } + + protected: + explicit IdentifyStoreItem(::google::protobuf::Arena* arena); + IdentifyStoreItem(::google::protobuf::Arena* arena, const IdentifyStoreItem& from); + IdentifyStoreItem(::google::protobuf::Arena* arena, IdentifyStoreItem&& from) noexcept + : IdentifyStoreItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<32> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.IdentifyStoreItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const IdentifyStoreItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class IdentifyItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.IdentifyItem) */ { + public: + inline IdentifyItem() : IdentifyItem(nullptr) {} + ~IdentifyItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(IdentifyItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(IdentifyItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR IdentifyItem( + ::google::protobuf::internal::ConstantInitialized); + + inline IdentifyItem(const IdentifyItem& from) : IdentifyItem(nullptr, from) {} + inline IdentifyItem(IdentifyItem&& from) noexcept + : IdentifyItem(nullptr, std::move(from)) {} + inline IdentifyItem& operator=(const IdentifyItem& from) { + CopyFrom(from); + return *this; + } + inline IdentifyItem& operator=(IdentifyItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const IdentifyItem& default_instance() { + return *internal_default_instance(); + } + static inline const IdentifyItem* internal_default_instance() { + return reinterpret_cast( + &_IdentifyItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 32; + friend void swap(IdentifyItem& a, IdentifyItem& b) { a.Swap(&b); } + inline void Swap(IdentifyItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(IdentifyItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + IdentifyItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const IdentifyItem& from); + void MergeFrom(const IdentifyItem& from) { IdentifyItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(IdentifyItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.IdentifyItem"; } + + protected: + explicit IdentifyItem(::google::protobuf::Arena* arena); + IdentifyItem(::google::protobuf::Arena* arena, const IdentifyItem& from); + IdentifyItem(::google::protobuf::Arena* arena, IdentifyItem&& from) noexcept + : IdentifyItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.IdentifyItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const IdentifyItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class GetItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.GetItem) */ { + public: + inline GetItem() : GetItem(nullptr) {} + ~GetItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(GetItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(GetItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR GetItem( + ::google::protobuf::internal::ConstantInitialized); + + inline GetItem(const GetItem& from) : GetItem(nullptr, from) {} + inline GetItem(GetItem&& from) noexcept + : GetItem(nullptr, std::move(from)) {} + inline GetItem& operator=(const GetItem& from) { + CopyFrom(from); + return *this; + } + inline GetItem& operator=(GetItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const GetItem& default_instance() { + return *internal_default_instance(); + } + static inline const GetItem* internal_default_instance() { + return reinterpret_cast( + &_GetItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 15; + friend void swap(GetItem& a, GetItem& b) { a.Swap(&b); } + inline void Swap(GetItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(GetItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + GetItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const GetItem& from); + void MergeFrom(const GetItem& from) { GetItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(GetItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.GetItem"; } + + protected: + explicit GetItem(::google::protobuf::Arena* arena); + GetItem(::google::protobuf::Arena* arena, const GetItem& from); + GetItem(::google::protobuf::Arena* arena, GetItem&& from) noexcept + : GetItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.GetItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const GetItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class DropCursorItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.DropCursorItem) */ { + public: + inline DropCursorItem() : DropCursorItem(nullptr) {} + ~DropCursorItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DropCursorItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DropCursorItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR DropCursorItem( + ::google::protobuf::internal::ConstantInitialized); + + inline DropCursorItem(const DropCursorItem& from) : DropCursorItem(nullptr, from) {} + inline DropCursorItem(DropCursorItem&& from) noexcept + : DropCursorItem(nullptr, std::move(from)) {} + inline DropCursorItem& operator=(const DropCursorItem& from) { + CopyFrom(from); + return *this; + } + inline DropCursorItem& operator=(DropCursorItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const DropCursorItem& default_instance() { + return *internal_default_instance(); + } + static inline const DropCursorItem* internal_default_instance() { + return reinterpret_cast( + &_DropCursorItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 22; + friend void swap(DropCursorItem& a, DropCursorItem& b) { a.Swap(&b); } + inline void Swap(DropCursorItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DropCursorItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DropCursorItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const DropCursorItem& from); + void MergeFrom(const DropCursorItem& from) { DropCursorItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DropCursorItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.DropCursorItem"; } + + protected: + explicit DropCursorItem(::google::protobuf::Arena* arena); + DropCursorItem(::google::protobuf::Arena* arena, const DropCursorItem& from); + DropCursorItem(::google::protobuf::Arena* arena, DropCursorItem&& from) noexcept + : DropCursorItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<29> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.DropCursorItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const DropCursorItem& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class DisarmTrap final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.DisarmTrap) */ { + public: + inline DisarmTrap() : DisarmTrap(nullptr) {} + ~DisarmTrap() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(DisarmTrap* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(DisarmTrap)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR DisarmTrap( + ::google::protobuf::internal::ConstantInitialized); + + inline DisarmTrap(const DisarmTrap& from) : DisarmTrap(nullptr, from) {} + inline DisarmTrap(DisarmTrap&& from) noexcept + : DisarmTrap(nullptr, std::move(from)) {} + inline DisarmTrap& operator=(const DisarmTrap& from) { + CopyFrom(from); + return *this; + } + inline DisarmTrap& operator=(DisarmTrap&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const DisarmTrap& default_instance() { + return *internal_default_instance(); + } + static inline const DisarmTrap* internal_default_instance() { + return reinterpret_cast( + &_DisarmTrap_default_instance_); + } + static constexpr int kIndexInFileMessages = 25; + friend void swap(DisarmTrap& a, DisarmTrap& b) { a.Swap(&b); } + inline void Swap(DisarmTrap* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(DisarmTrap* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + DisarmTrap* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const DisarmTrap& from); + void MergeFrom(const DisarmTrap& from) { DisarmTrap::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(DisarmTrap* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.DisarmTrap"; } + + protected: + explicit DisarmTrap(::google::protobuf::Arena* arena); + DisarmTrap(::google::protobuf::Arena* arena, const DisarmTrap& from); + DisarmTrap(::google::protobuf::Arena* arena, DisarmTrap&& from) noexcept + : DisarmTrap(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIndexFieldNumber = 1, + }; + // uint32 index = 1; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.DisarmTrap) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const DisarmTrap& from_msg); + ::uint32_t index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class ClearCursor final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.ClearCursor) */ { + public: + inline ClearCursor() : ClearCursor(nullptr) {} + ~ClearCursor() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClearCursor* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClearCursor)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClearCursor( + ::google::protobuf::internal::ConstantInitialized); + + inline ClearCursor(const ClearCursor& from) : ClearCursor(nullptr, from) {} + inline ClearCursor(ClearCursor&& from) noexcept + : ClearCursor(nullptr, std::move(from)) {} + inline ClearCursor& operator=(const ClearCursor& from) { + CopyFrom(from); + return *this; + } + inline ClearCursor& operator=(ClearCursor&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClearCursor& default_instance() { + return *internal_default_instance(); + } + static inline const ClearCursor* internal_default_instance() { + return reinterpret_cast( + &_ClearCursor_default_instance_); + } + static constexpr int kIndexInFileMessages = 31; + friend void swap(ClearCursor& a, ClearCursor& b) { a.Swap(&b); } + inline void Swap(ClearCursor* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClearCursor* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClearCursor* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ClearCursor& from); + void MergeFrom(const ClearCursor& from) { ClearCursor::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClearCursor* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.ClearCursor"; } + + protected: + explicit ClearCursor(::google::protobuf::Arena* arena); + ClearCursor(::google::protobuf::Arena* arena, const ClearCursor& from); + ClearCursor(::google::protobuf::Arena* arena, ClearCursor&& from) noexcept + : ClearCursor(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.ClearCursor) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ClearCursor& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class CastXY final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.CastXY) */ { + public: + inline CastXY() : CastXY(nullptr) {} + ~CastXY() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CastXY* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CastXY)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CastXY( + ::google::protobuf::internal::ConstantInitialized); + + inline CastXY(const CastXY& from) : CastXY(nullptr, from) {} + inline CastXY(CastXY&& from) noexcept + : CastXY(nullptr, std::move(from)) {} + inline CastXY& operator=(const CastXY& from) { + CopyFrom(from); + return *this; + } + inline CastXY& operator=(CastXY&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const CastXY& default_instance() { + return *internal_default_instance(); + } + static inline const CastXY* internal_default_instance() { + return reinterpret_cast( + &_CastXY_default_instance_); + } + static constexpr int kIndexInFileMessages = 18; + friend void swap(CastXY& a, CastXY& b) { a.Swap(&b); } + inline void Swap(CastXY* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CastXY* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CastXY* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const CastXY& from); + void MergeFrom(const CastXY& from) { CastXY::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CastXY* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.CastXY"; } + + protected: + explicit CastXY(::google::protobuf::Arena* arena); + CastXY(::google::protobuf::Arena* arena, const CastXY& from); + CastXY(::google::protobuf::Arena* arena, CastXY&& from) noexcept + : CastXY(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + // sint32 x = 1; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // sint32 y = 2; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.CastXY) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CastXY& from_msg); + ::int32_t x_; + ::int32_t y_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class CastMonster final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.CastMonster) */ { + public: + inline CastMonster() : CastMonster(nullptr) {} + ~CastMonster() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CastMonster* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CastMonster)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CastMonster( + ::google::protobuf::internal::ConstantInitialized); + + inline CastMonster(const CastMonster& from) : CastMonster(nullptr, from) {} + inline CastMonster(CastMonster&& from) noexcept + : CastMonster(nullptr, std::move(from)) {} + inline CastMonster& operator=(const CastMonster& from) { + CopyFrom(from); + return *this; + } + inline CastMonster& operator=(CastMonster&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const CastMonster& default_instance() { + return *internal_default_instance(); + } + static inline const CastMonster* internal_default_instance() { + return reinterpret_cast( + &_CastMonster_default_instance_); + } + static constexpr int kIndexInFileMessages = 17; + friend void swap(CastMonster& a, CastMonster& b) { a.Swap(&b); } + inline void Swap(CastMonster* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CastMonster* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CastMonster* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const CastMonster& from); + void MergeFrom(const CastMonster& from) { CastMonster::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CastMonster* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.CastMonster"; } + + protected: + explicit CastMonster(::google::protobuf::Arena* arena); + CastMonster(::google::protobuf::Arena* arena, const CastMonster& from); + CastMonster(::google::protobuf::Arena* arena, CastMonster&& from) noexcept + : CastMonster(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIndexFieldNumber = 1, + }; + // uint32 index = 1; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.CastMonster) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CastMonster& from_msg); + ::uint32_t index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class CancelQText final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.CancelQText) */ { + public: + inline CancelQText() : CancelQText(nullptr) {} + ~CancelQText() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(CancelQText* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(CancelQText)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR CancelQText( + ::google::protobuf::internal::ConstantInitialized); + + inline CancelQText(const CancelQText& from) : CancelQText(nullptr, from) {} + inline CancelQText(CancelQText&& from) noexcept + : CancelQText(nullptr, std::move(from)) {} + inline CancelQText& operator=(const CancelQText& from) { + CopyFrom(from); + return *this; + } + inline CancelQText& operator=(CancelQText&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const CancelQText& default_instance() { + return *internal_default_instance(); + } + static inline const CancelQText* internal_default_instance() { + return reinterpret_cast( + &_CancelQText_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(CancelQText& a, CancelQText& b) { a.Swap(&b); } + inline void Swap(CancelQText* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(CancelQText* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + CancelQText* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const CancelQText& from); + void MergeFrom(const CancelQText& from) { CancelQText::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(CancelQText* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.CancelQText"; } + + protected: + explicit CancelQText(::google::protobuf::Arena* arena); + CancelQText(::google::protobuf::Arena* arena, const CancelQText& from); + CancelQText(::google::protobuf::Arena* arena, CancelQText&& from) noexcept + : CancelQText(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.commands.CancelQText) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const CancelQText& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class BuyItem final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.BuyItem) */ { + public: + inline BuyItem() : BuyItem(nullptr) {} + ~BuyItem() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(BuyItem* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(BuyItem)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR BuyItem( + ::google::protobuf::internal::ConstantInitialized); + + inline BuyItem(const BuyItem& from) : BuyItem(nullptr, from) {} + inline BuyItem(BuyItem&& from) noexcept + : BuyItem(nullptr, std::move(from)) {} + inline BuyItem& operator=(const BuyItem& from) { + CopyFrom(from); + return *this; + } + inline BuyItem& operator=(BuyItem&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const BuyItem& default_instance() { + return *internal_default_instance(); + } + static inline const BuyItem* internal_default_instance() { + return reinterpret_cast( + &_BuyItem_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + friend void swap(BuyItem& a, BuyItem& b) { a.Swap(&b); } + inline void Swap(BuyItem* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(BuyItem* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + BuyItem* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const BuyItem& from); + void MergeFrom(const BuyItem& from) { BuyItem::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(BuyItem* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.BuyItem"; } + + protected: + explicit BuyItem(::google::protobuf::Arena* arena); + BuyItem(::google::protobuf::Arena* arena, const BuyItem& from); + BuyItem(::google::protobuf::Arena* arena, BuyItem&& from) noexcept + : BuyItem(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIDFieldNumber = 1, + }; + // 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: + // @@protoc_insertion_point(class_scope:dapi.commands.BuyItem) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const BuyItem& from_msg); + ::uint32_t id_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class AttackXY final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.AttackXY) */ { + public: + inline AttackXY() : AttackXY(nullptr) {} + ~AttackXY() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(AttackXY* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(AttackXY)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR AttackXY( + ::google::protobuf::internal::ConstantInitialized); + + inline AttackXY(const AttackXY& from) : AttackXY(nullptr, from) {} + inline AttackXY(AttackXY&& from) noexcept + : AttackXY(nullptr, std::move(from)) {} + inline AttackXY& operator=(const AttackXY& from) { + CopyFrom(from); + return *this; + } + inline AttackXY& operator=(AttackXY&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AttackXY& default_instance() { + return *internal_default_instance(); + } + static inline const AttackXY* internal_default_instance() { + return reinterpret_cast( + &_AttackXY_default_instance_); + } + static constexpr int kIndexInFileMessages = 10; + friend void swap(AttackXY& a, AttackXY& b) { a.Swap(&b); } + inline void Swap(AttackXY* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AttackXY* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AttackXY* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const AttackXY& from); + void MergeFrom(const AttackXY& from) { AttackXY::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(AttackXY* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.AttackXY"; } + + protected: + explicit AttackXY(::google::protobuf::Arena* arena); + AttackXY(::google::protobuf::Arena* arena, const AttackXY& from); + AttackXY(::google::protobuf::Arena* arena, AttackXY&& from) noexcept + : AttackXY(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + }; + // sint32 x = 1; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // sint32 y = 2; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.AttackXY) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const AttackXY& from_msg); + ::int32_t x_; + ::int32_t y_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class AttackMonster final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.AttackMonster) */ { + public: + inline AttackMonster() : AttackMonster(nullptr) {} + ~AttackMonster() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(AttackMonster* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(AttackMonster)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR AttackMonster( + ::google::protobuf::internal::ConstantInitialized); + + inline AttackMonster(const AttackMonster& from) : AttackMonster(nullptr, from) {} + inline AttackMonster(AttackMonster&& from) noexcept + : AttackMonster(nullptr, std::move(from)) {} + inline AttackMonster& operator=(const AttackMonster& from) { + CopyFrom(from); + return *this; + } + inline AttackMonster& operator=(AttackMonster&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const AttackMonster& default_instance() { + return *internal_default_instance(); + } + static inline const AttackMonster* internal_default_instance() { + return reinterpret_cast( + &_AttackMonster_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + friend void swap(AttackMonster& a, AttackMonster& b) { a.Swap(&b); } + inline void Swap(AttackMonster* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(AttackMonster* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + AttackMonster* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const AttackMonster& from); + void MergeFrom(const AttackMonster& from) { AttackMonster::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(AttackMonster* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.AttackMonster"; } + + protected: + explicit AttackMonster(::google::protobuf::Arena* arena); + AttackMonster(::google::protobuf::Arena* arena, const AttackMonster& from); + AttackMonster(::google::protobuf::Arena* arena, AttackMonster&& from) noexcept + : AttackMonster(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIndexFieldNumber = 1, + }; + // uint32 index = 1; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.commands.AttackMonster) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const AttackMonster& from_msg); + ::uint32_t index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; +// ------------------------------------------------------------------- + +class Command final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.commands.Command) */ { + public: + inline Command() : Command(nullptr) {} + ~Command() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Command* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Command)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Command( + ::google::protobuf::internal::ConstantInitialized); + + inline Command(const Command& from) : Command(nullptr, from) {} + inline Command(Command&& from) noexcept + : Command(nullptr, std::move(from)) {} + inline Command& operator=(const Command& from) { + CopyFrom(from); + return *this; + } + inline Command& operator=(Command&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const Command& default_instance() { + return *internal_default_instance(); + } + enum CommandCase { + kMove = 1, + kTalk = 2, + kOption = 3, + kBuyItem = 4, + kSellItem = 5, + kRechargeItem = 6, + kRepairItem = 7, + kAttackMonster = 8, + kAttackXY = 9, + kOperateObject = 10, + kUseBeltItem = 11, + kToggleCharacterSheet = 12, + kIncreaseStat = 13, + kGetItem = 14, + kSetSpell = 15, + kCastMonster = 16, + kCastXY = 17, + kToggleInventory = 18, + kPutInCursor = 19, + kPutCursorItem = 20, + kDropCursorItem = 21, + kUseItem = 22, + kIdentifyStoreItem = 23, + kCancelQText = 24, + kSetFPS = 25, + kDisarmTrap = 26, + kSkillRepair = 27, + kSkillRecharge = 28, + kToggleMenu = 29, + kSaveGame = 30, + kQuit = 31, + kClearCursor = 32, + kIdentifyItem = 33, + COMMAND_NOT_SET = 0, + }; + static inline const Command* internal_default_instance() { + return reinterpret_cast( + &_Command_default_instance_); + } + static constexpr int kIndexInFileMessages = 33; + friend void swap(Command& a, Command& b) { a.Swap(&b); } + inline void Swap(Command* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Command* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Command* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const Command& from); + void MergeFrom(const Command& from) { Command::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Command* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.commands.Command"; } + + protected: + explicit Command(::google::protobuf::Arena* arena); + Command(::google::protobuf::Arena* arena, const Command& from); + Command(::google::protobuf::Arena* arena, Command&& from) noexcept + : Command(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kMoveFieldNumber = 1, + kTalkFieldNumber = 2, + kOptionFieldNumber = 3, + kBuyItemFieldNumber = 4, + kSellItemFieldNumber = 5, + kRechargeItemFieldNumber = 6, + kRepairItemFieldNumber = 7, + kAttackMonsterFieldNumber = 8, + kAttackXYFieldNumber = 9, + kOperateObjectFieldNumber = 10, + kUseBeltItemFieldNumber = 11, + kToggleCharacterSheetFieldNumber = 12, + kIncreaseStatFieldNumber = 13, + kGetItemFieldNumber = 14, + kSetSpellFieldNumber = 15, + kCastMonsterFieldNumber = 16, + kCastXYFieldNumber = 17, + kToggleInventoryFieldNumber = 18, + kPutInCursorFieldNumber = 19, + kPutCursorItemFieldNumber = 20, + kDropCursorItemFieldNumber = 21, + kUseItemFieldNumber = 22, + kIdentifyStoreItemFieldNumber = 23, + kCancelQTextFieldNumber = 24, + kSetFPSFieldNumber = 25, + kDisarmTrapFieldNumber = 26, + kSkillRepairFieldNumber = 27, + kSkillRechargeFieldNumber = 28, + kToggleMenuFieldNumber = 29, + kSaveGameFieldNumber = 30, + kQuitFieldNumber = 31, + kClearCursorFieldNumber = 32, + kIdentifyItemFieldNumber = 33, + }; + // .dapi.commands.Move move = 1; + bool has_move() const; + private: + bool _internal_has_move() const; + + public: + void clear_move() ; + const ::dapi::commands::Move& move() const; + PROTOBUF_NODISCARD ::dapi::commands::Move* release_move(); + ::dapi::commands::Move* mutable_move(); + void set_allocated_move(::dapi::commands::Move* value); + void unsafe_arena_set_allocated_move(::dapi::commands::Move* value); + ::dapi::commands::Move* unsafe_arena_release_move(); + + private: + const ::dapi::commands::Move& _internal_move() const; + ::dapi::commands::Move* _internal_mutable_move(); + + public: + // .dapi.commands.Talk talk = 2; + bool has_talk() const; + private: + bool _internal_has_talk() const; + + public: + void clear_talk() ; + const ::dapi::commands::Talk& talk() const; + PROTOBUF_NODISCARD ::dapi::commands::Talk* release_talk(); + ::dapi::commands::Talk* mutable_talk(); + void set_allocated_talk(::dapi::commands::Talk* value); + void unsafe_arena_set_allocated_talk(::dapi::commands::Talk* value); + ::dapi::commands::Talk* unsafe_arena_release_talk(); + + private: + const ::dapi::commands::Talk& _internal_talk() const; + ::dapi::commands::Talk* _internal_mutable_talk(); + + public: + // .dapi.commands.SelectStoreOption option = 3; + bool has_option() const; + private: + bool _internal_has_option() const; + + public: + void clear_option() ; + const ::dapi::commands::SelectStoreOption& option() const; + PROTOBUF_NODISCARD ::dapi::commands::SelectStoreOption* release_option(); + ::dapi::commands::SelectStoreOption* mutable_option(); + void set_allocated_option(::dapi::commands::SelectStoreOption* value); + void unsafe_arena_set_allocated_option(::dapi::commands::SelectStoreOption* value); + ::dapi::commands::SelectStoreOption* unsafe_arena_release_option(); + + private: + const ::dapi::commands::SelectStoreOption& _internal_option() const; + ::dapi::commands::SelectStoreOption* _internal_mutable_option(); + + public: + // .dapi.commands.BuyItem buyItem = 4; + bool has_buyitem() const; + private: + bool _internal_has_buyitem() const; + + public: + void clear_buyitem() ; + const ::dapi::commands::BuyItem& buyitem() const; + PROTOBUF_NODISCARD ::dapi::commands::BuyItem* release_buyitem(); + ::dapi::commands::BuyItem* mutable_buyitem(); + void set_allocated_buyitem(::dapi::commands::BuyItem* value); + void unsafe_arena_set_allocated_buyitem(::dapi::commands::BuyItem* value); + ::dapi::commands::BuyItem* unsafe_arena_release_buyitem(); + + private: + const ::dapi::commands::BuyItem& _internal_buyitem() const; + ::dapi::commands::BuyItem* _internal_mutable_buyitem(); + + public: + // .dapi.commands.SellItem sellItem = 5; + bool has_sellitem() const; + private: + bool _internal_has_sellitem() const; + + public: + void clear_sellitem() ; + const ::dapi::commands::SellItem& sellitem() const; + PROTOBUF_NODISCARD ::dapi::commands::SellItem* release_sellitem(); + ::dapi::commands::SellItem* mutable_sellitem(); + void set_allocated_sellitem(::dapi::commands::SellItem* value); + void unsafe_arena_set_allocated_sellitem(::dapi::commands::SellItem* value); + ::dapi::commands::SellItem* unsafe_arena_release_sellitem(); + + private: + const ::dapi::commands::SellItem& _internal_sellitem() const; + ::dapi::commands::SellItem* _internal_mutable_sellitem(); + + public: + // .dapi.commands.RechargeItem rechargeItem = 6; + bool has_rechargeitem() const; + private: + bool _internal_has_rechargeitem() const; + + public: + void clear_rechargeitem() ; + const ::dapi::commands::RechargeItem& rechargeitem() const; + PROTOBUF_NODISCARD ::dapi::commands::RechargeItem* release_rechargeitem(); + ::dapi::commands::RechargeItem* mutable_rechargeitem(); + void set_allocated_rechargeitem(::dapi::commands::RechargeItem* value); + void unsafe_arena_set_allocated_rechargeitem(::dapi::commands::RechargeItem* value); + ::dapi::commands::RechargeItem* unsafe_arena_release_rechargeitem(); + + private: + const ::dapi::commands::RechargeItem& _internal_rechargeitem() const; + ::dapi::commands::RechargeItem* _internal_mutable_rechargeitem(); + + public: + // .dapi.commands.RepairItem repairItem = 7; + bool has_repairitem() const; + private: + bool _internal_has_repairitem() const; + + public: + void clear_repairitem() ; + const ::dapi::commands::RepairItem& repairitem() const; + PROTOBUF_NODISCARD ::dapi::commands::RepairItem* release_repairitem(); + ::dapi::commands::RepairItem* mutable_repairitem(); + void set_allocated_repairitem(::dapi::commands::RepairItem* value); + void unsafe_arena_set_allocated_repairitem(::dapi::commands::RepairItem* value); + ::dapi::commands::RepairItem* unsafe_arena_release_repairitem(); + + private: + const ::dapi::commands::RepairItem& _internal_repairitem() const; + ::dapi::commands::RepairItem* _internal_mutable_repairitem(); + + public: + // .dapi.commands.AttackMonster attackMonster = 8; + bool has_attackmonster() const; + private: + bool _internal_has_attackmonster() const; + + public: + void clear_attackmonster() ; + const ::dapi::commands::AttackMonster& attackmonster() const; + PROTOBUF_NODISCARD ::dapi::commands::AttackMonster* release_attackmonster(); + ::dapi::commands::AttackMonster* mutable_attackmonster(); + void set_allocated_attackmonster(::dapi::commands::AttackMonster* value); + void unsafe_arena_set_allocated_attackmonster(::dapi::commands::AttackMonster* value); + ::dapi::commands::AttackMonster* unsafe_arena_release_attackmonster(); + + private: + const ::dapi::commands::AttackMonster& _internal_attackmonster() const; + ::dapi::commands::AttackMonster* _internal_mutable_attackmonster(); + + public: + // .dapi.commands.AttackXY attackXY = 9; + bool has_attackxy() const; + private: + bool _internal_has_attackxy() const; + + public: + void clear_attackxy() ; + const ::dapi::commands::AttackXY& attackxy() const; + PROTOBUF_NODISCARD ::dapi::commands::AttackXY* release_attackxy(); + ::dapi::commands::AttackXY* mutable_attackxy(); + void set_allocated_attackxy(::dapi::commands::AttackXY* value); + void unsafe_arena_set_allocated_attackxy(::dapi::commands::AttackXY* value); + ::dapi::commands::AttackXY* unsafe_arena_release_attackxy(); + + private: + const ::dapi::commands::AttackXY& _internal_attackxy() const; + ::dapi::commands::AttackXY* _internal_mutable_attackxy(); + + public: + // .dapi.commands.OperateObject operateObject = 10; + bool has_operateobject() const; + private: + bool _internal_has_operateobject() const; + + public: + void clear_operateobject() ; + const ::dapi::commands::OperateObject& operateobject() const; + PROTOBUF_NODISCARD ::dapi::commands::OperateObject* release_operateobject(); + ::dapi::commands::OperateObject* mutable_operateobject(); + void set_allocated_operateobject(::dapi::commands::OperateObject* value); + void unsafe_arena_set_allocated_operateobject(::dapi::commands::OperateObject* value); + ::dapi::commands::OperateObject* unsafe_arena_release_operateobject(); + + private: + const ::dapi::commands::OperateObject& _internal_operateobject() const; + ::dapi::commands::OperateObject* _internal_mutable_operateobject(); + + public: + // .dapi.commands.UseBeltItem useBeltItem = 11; + bool has_usebeltitem() const; + private: + bool _internal_has_usebeltitem() const; + + public: + void clear_usebeltitem() ; + const ::dapi::commands::UseBeltItem& usebeltitem() const; + PROTOBUF_NODISCARD ::dapi::commands::UseBeltItem* release_usebeltitem(); + ::dapi::commands::UseBeltItem* mutable_usebeltitem(); + void set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value); + void unsafe_arena_set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value); + ::dapi::commands::UseBeltItem* unsafe_arena_release_usebeltitem(); + + private: + const ::dapi::commands::UseBeltItem& _internal_usebeltitem() const; + ::dapi::commands::UseBeltItem* _internal_mutable_usebeltitem(); + + public: + // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; + bool has_togglecharactersheet() const; + private: + bool _internal_has_togglecharactersheet() const; + + public: + void clear_togglecharactersheet() ; + const ::dapi::commands::ToggleCharacterSheet& togglecharactersheet() const; + PROTOBUF_NODISCARD ::dapi::commands::ToggleCharacterSheet* release_togglecharactersheet(); + ::dapi::commands::ToggleCharacterSheet* mutable_togglecharactersheet(); + void set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value); + void unsafe_arena_set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value); + ::dapi::commands::ToggleCharacterSheet* unsafe_arena_release_togglecharactersheet(); + + private: + const ::dapi::commands::ToggleCharacterSheet& _internal_togglecharactersheet() const; + ::dapi::commands::ToggleCharacterSheet* _internal_mutable_togglecharactersheet(); + + public: + // .dapi.commands.IncreaseStat increaseStat = 13; + bool has_increasestat() const; + private: + bool _internal_has_increasestat() const; + + public: + void clear_increasestat() ; + const ::dapi::commands::IncreaseStat& increasestat() const; + PROTOBUF_NODISCARD ::dapi::commands::IncreaseStat* release_increasestat(); + ::dapi::commands::IncreaseStat* mutable_increasestat(); + void set_allocated_increasestat(::dapi::commands::IncreaseStat* value); + void unsafe_arena_set_allocated_increasestat(::dapi::commands::IncreaseStat* value); + ::dapi::commands::IncreaseStat* unsafe_arena_release_increasestat(); + + private: + const ::dapi::commands::IncreaseStat& _internal_increasestat() const; + ::dapi::commands::IncreaseStat* _internal_mutable_increasestat(); + + public: + // .dapi.commands.GetItem getItem = 14; + bool has_getitem() const; + private: + bool _internal_has_getitem() const; + + public: + void clear_getitem() ; + const ::dapi::commands::GetItem& getitem() const; + PROTOBUF_NODISCARD ::dapi::commands::GetItem* release_getitem(); + ::dapi::commands::GetItem* mutable_getitem(); + void set_allocated_getitem(::dapi::commands::GetItem* value); + void unsafe_arena_set_allocated_getitem(::dapi::commands::GetItem* value); + ::dapi::commands::GetItem* unsafe_arena_release_getitem(); + + private: + const ::dapi::commands::GetItem& _internal_getitem() const; + ::dapi::commands::GetItem* _internal_mutable_getitem(); + + public: + // .dapi.commands.SetSpell setSpell = 15; + bool has_setspell() const; + private: + bool _internal_has_setspell() const; + + public: + void clear_setspell() ; + const ::dapi::commands::SetSpell& setspell() const; + PROTOBUF_NODISCARD ::dapi::commands::SetSpell* release_setspell(); + ::dapi::commands::SetSpell* mutable_setspell(); + void set_allocated_setspell(::dapi::commands::SetSpell* value); + void unsafe_arena_set_allocated_setspell(::dapi::commands::SetSpell* value); + ::dapi::commands::SetSpell* unsafe_arena_release_setspell(); + + private: + const ::dapi::commands::SetSpell& _internal_setspell() const; + ::dapi::commands::SetSpell* _internal_mutable_setspell(); + + public: + // .dapi.commands.CastMonster castMonster = 16; + bool has_castmonster() const; + private: + bool _internal_has_castmonster() const; + + public: + void clear_castmonster() ; + const ::dapi::commands::CastMonster& castmonster() const; + PROTOBUF_NODISCARD ::dapi::commands::CastMonster* release_castmonster(); + ::dapi::commands::CastMonster* mutable_castmonster(); + void set_allocated_castmonster(::dapi::commands::CastMonster* value); + void unsafe_arena_set_allocated_castmonster(::dapi::commands::CastMonster* value); + ::dapi::commands::CastMonster* unsafe_arena_release_castmonster(); + + private: + const ::dapi::commands::CastMonster& _internal_castmonster() const; + ::dapi::commands::CastMonster* _internal_mutable_castmonster(); + + public: + // .dapi.commands.CastXY castXY = 17; + bool has_castxy() const; + private: + bool _internal_has_castxy() const; + + public: + void clear_castxy() ; + const ::dapi::commands::CastXY& castxy() const; + PROTOBUF_NODISCARD ::dapi::commands::CastXY* release_castxy(); + ::dapi::commands::CastXY* mutable_castxy(); + void set_allocated_castxy(::dapi::commands::CastXY* value); + void unsafe_arena_set_allocated_castxy(::dapi::commands::CastXY* value); + ::dapi::commands::CastXY* unsafe_arena_release_castxy(); + + private: + const ::dapi::commands::CastXY& _internal_castxy() const; + ::dapi::commands::CastXY* _internal_mutable_castxy(); + + public: + // .dapi.commands.ToggleInventory toggleInventory = 18; + bool has_toggleinventory() const; + private: + bool _internal_has_toggleinventory() const; + + public: + void clear_toggleinventory() ; + const ::dapi::commands::ToggleInventory& toggleinventory() const; + PROTOBUF_NODISCARD ::dapi::commands::ToggleInventory* release_toggleinventory(); + ::dapi::commands::ToggleInventory* mutable_toggleinventory(); + void set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value); + void unsafe_arena_set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value); + ::dapi::commands::ToggleInventory* unsafe_arena_release_toggleinventory(); + + private: + const ::dapi::commands::ToggleInventory& _internal_toggleinventory() const; + ::dapi::commands::ToggleInventory* _internal_mutable_toggleinventory(); + + public: + // .dapi.commands.PutInCursor putInCursor = 19; + bool has_putincursor() const; + private: + bool _internal_has_putincursor() const; + + public: + void clear_putincursor() ; + const ::dapi::commands::PutInCursor& putincursor() const; + PROTOBUF_NODISCARD ::dapi::commands::PutInCursor* release_putincursor(); + ::dapi::commands::PutInCursor* mutable_putincursor(); + void set_allocated_putincursor(::dapi::commands::PutInCursor* value); + void unsafe_arena_set_allocated_putincursor(::dapi::commands::PutInCursor* value); + ::dapi::commands::PutInCursor* unsafe_arena_release_putincursor(); + + private: + const ::dapi::commands::PutInCursor& _internal_putincursor() const; + ::dapi::commands::PutInCursor* _internal_mutable_putincursor(); + + public: + // .dapi.commands.PutCursorItem putCursorItem = 20; + bool has_putcursoritem() const; + private: + bool _internal_has_putcursoritem() const; + + public: + void clear_putcursoritem() ; + const ::dapi::commands::PutCursorItem& putcursoritem() const; + PROTOBUF_NODISCARD ::dapi::commands::PutCursorItem* release_putcursoritem(); + ::dapi::commands::PutCursorItem* mutable_putcursoritem(); + void set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value); + void unsafe_arena_set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value); + ::dapi::commands::PutCursorItem* unsafe_arena_release_putcursoritem(); + + private: + const ::dapi::commands::PutCursorItem& _internal_putcursoritem() const; + ::dapi::commands::PutCursorItem* _internal_mutable_putcursoritem(); + + public: + // .dapi.commands.DropCursorItem dropCursorItem = 21; + bool has_dropcursoritem() const; + private: + bool _internal_has_dropcursoritem() const; + + public: + void clear_dropcursoritem() ; + const ::dapi::commands::DropCursorItem& dropcursoritem() const; + PROTOBUF_NODISCARD ::dapi::commands::DropCursorItem* release_dropcursoritem(); + ::dapi::commands::DropCursorItem* mutable_dropcursoritem(); + void set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value); + void unsafe_arena_set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value); + ::dapi::commands::DropCursorItem* unsafe_arena_release_dropcursoritem(); + + private: + const ::dapi::commands::DropCursorItem& _internal_dropcursoritem() const; + ::dapi::commands::DropCursorItem* _internal_mutable_dropcursoritem(); + + public: + // .dapi.commands.UseItem useItem = 22; + bool has_useitem() const; + private: + bool _internal_has_useitem() const; + + public: + void clear_useitem() ; + const ::dapi::commands::UseItem& useitem() const; + PROTOBUF_NODISCARD ::dapi::commands::UseItem* release_useitem(); + ::dapi::commands::UseItem* mutable_useitem(); + void set_allocated_useitem(::dapi::commands::UseItem* value); + void unsafe_arena_set_allocated_useitem(::dapi::commands::UseItem* value); + ::dapi::commands::UseItem* unsafe_arena_release_useitem(); + + private: + const ::dapi::commands::UseItem& _internal_useitem() const; + ::dapi::commands::UseItem* _internal_mutable_useitem(); + + public: + // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; + bool has_identifystoreitem() const; + private: + bool _internal_has_identifystoreitem() const; + + public: + void clear_identifystoreitem() ; + const ::dapi::commands::IdentifyStoreItem& identifystoreitem() const; + PROTOBUF_NODISCARD ::dapi::commands::IdentifyStoreItem* release_identifystoreitem(); + ::dapi::commands::IdentifyStoreItem* mutable_identifystoreitem(); + void set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value); + void unsafe_arena_set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value); + ::dapi::commands::IdentifyStoreItem* unsafe_arena_release_identifystoreitem(); + + private: + const ::dapi::commands::IdentifyStoreItem& _internal_identifystoreitem() const; + ::dapi::commands::IdentifyStoreItem* _internal_mutable_identifystoreitem(); + + public: + // .dapi.commands.CancelQText cancelQText = 24; + bool has_cancelqtext() const; + private: + bool _internal_has_cancelqtext() const; + + public: + void clear_cancelqtext() ; + const ::dapi::commands::CancelQText& cancelqtext() const; + PROTOBUF_NODISCARD ::dapi::commands::CancelQText* release_cancelqtext(); + ::dapi::commands::CancelQText* mutable_cancelqtext(); + void set_allocated_cancelqtext(::dapi::commands::CancelQText* value); + void unsafe_arena_set_allocated_cancelqtext(::dapi::commands::CancelQText* value); + ::dapi::commands::CancelQText* unsafe_arena_release_cancelqtext(); + + private: + const ::dapi::commands::CancelQText& _internal_cancelqtext() const; + ::dapi::commands::CancelQText* _internal_mutable_cancelqtext(); + + public: + // .dapi.commands.SetFPS setFPS = 25; + bool has_setfps() const; + private: + bool _internal_has_setfps() const; + + public: + void clear_setfps() ; + const ::dapi::commands::SetFPS& setfps() const; + PROTOBUF_NODISCARD ::dapi::commands::SetFPS* release_setfps(); + ::dapi::commands::SetFPS* mutable_setfps(); + void set_allocated_setfps(::dapi::commands::SetFPS* value); + void unsafe_arena_set_allocated_setfps(::dapi::commands::SetFPS* value); + ::dapi::commands::SetFPS* unsafe_arena_release_setfps(); + + private: + const ::dapi::commands::SetFPS& _internal_setfps() const; + ::dapi::commands::SetFPS* _internal_mutable_setfps(); + + public: + // .dapi.commands.DisarmTrap disarmTrap = 26; + bool has_disarmtrap() const; + private: + bool _internal_has_disarmtrap() const; + + public: + void clear_disarmtrap() ; + const ::dapi::commands::DisarmTrap& disarmtrap() const; + PROTOBUF_NODISCARD ::dapi::commands::DisarmTrap* release_disarmtrap(); + ::dapi::commands::DisarmTrap* mutable_disarmtrap(); + void set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value); + void unsafe_arena_set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value); + ::dapi::commands::DisarmTrap* unsafe_arena_release_disarmtrap(); + + private: + const ::dapi::commands::DisarmTrap& _internal_disarmtrap() const; + ::dapi::commands::DisarmTrap* _internal_mutable_disarmtrap(); + + public: + // .dapi.commands.SkillRepair skillRepair = 27; + bool has_skillrepair() const; + private: + bool _internal_has_skillrepair() const; + + public: + void clear_skillrepair() ; + const ::dapi::commands::SkillRepair& skillrepair() const; + PROTOBUF_NODISCARD ::dapi::commands::SkillRepair* release_skillrepair(); + ::dapi::commands::SkillRepair* mutable_skillrepair(); + void set_allocated_skillrepair(::dapi::commands::SkillRepair* value); + void unsafe_arena_set_allocated_skillrepair(::dapi::commands::SkillRepair* value); + ::dapi::commands::SkillRepair* unsafe_arena_release_skillrepair(); + + private: + const ::dapi::commands::SkillRepair& _internal_skillrepair() const; + ::dapi::commands::SkillRepair* _internal_mutable_skillrepair(); + + public: + // .dapi.commands.SkillRecharge skillRecharge = 28; + bool has_skillrecharge() const; + private: + bool _internal_has_skillrecharge() const; + + public: + void clear_skillrecharge() ; + const ::dapi::commands::SkillRecharge& skillrecharge() const; + PROTOBUF_NODISCARD ::dapi::commands::SkillRecharge* release_skillrecharge(); + ::dapi::commands::SkillRecharge* mutable_skillrecharge(); + void set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value); + void unsafe_arena_set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value); + ::dapi::commands::SkillRecharge* unsafe_arena_release_skillrecharge(); + + private: + const ::dapi::commands::SkillRecharge& _internal_skillrecharge() const; + ::dapi::commands::SkillRecharge* _internal_mutable_skillrecharge(); + + public: + // .dapi.commands.ToggleMenu toggleMenu = 29; + bool has_togglemenu() const; + private: + bool _internal_has_togglemenu() const; + + public: + void clear_togglemenu() ; + const ::dapi::commands::ToggleMenu& togglemenu() const; + PROTOBUF_NODISCARD ::dapi::commands::ToggleMenu* release_togglemenu(); + ::dapi::commands::ToggleMenu* mutable_togglemenu(); + void set_allocated_togglemenu(::dapi::commands::ToggleMenu* value); + void unsafe_arena_set_allocated_togglemenu(::dapi::commands::ToggleMenu* value); + ::dapi::commands::ToggleMenu* unsafe_arena_release_togglemenu(); + + private: + const ::dapi::commands::ToggleMenu& _internal_togglemenu() const; + ::dapi::commands::ToggleMenu* _internal_mutable_togglemenu(); + + public: + // .dapi.commands.SaveGame saveGame = 30; + bool has_savegame() const; + private: + bool _internal_has_savegame() const; + + public: + void clear_savegame() ; + const ::dapi::commands::SaveGame& savegame() const; + PROTOBUF_NODISCARD ::dapi::commands::SaveGame* release_savegame(); + ::dapi::commands::SaveGame* mutable_savegame(); + void set_allocated_savegame(::dapi::commands::SaveGame* value); + void unsafe_arena_set_allocated_savegame(::dapi::commands::SaveGame* value); + ::dapi::commands::SaveGame* unsafe_arena_release_savegame(); + + private: + const ::dapi::commands::SaveGame& _internal_savegame() const; + ::dapi::commands::SaveGame* _internal_mutable_savegame(); + + public: + // .dapi.commands.Quit quit = 31; + bool has_quit() const; + private: + bool _internal_has_quit() const; + + public: + void clear_quit() ; + const ::dapi::commands::Quit& quit() const; + PROTOBUF_NODISCARD ::dapi::commands::Quit* release_quit(); + ::dapi::commands::Quit* mutable_quit(); + void set_allocated_quit(::dapi::commands::Quit* value); + void unsafe_arena_set_allocated_quit(::dapi::commands::Quit* value); + ::dapi::commands::Quit* unsafe_arena_release_quit(); + + private: + const ::dapi::commands::Quit& _internal_quit() const; + ::dapi::commands::Quit* _internal_mutable_quit(); + + public: + // .dapi.commands.ClearCursor clearCursor = 32; + bool has_clearcursor() const; + private: + bool _internal_has_clearcursor() const; + + public: + void clear_clearcursor() ; + const ::dapi::commands::ClearCursor& clearcursor() const; + PROTOBUF_NODISCARD ::dapi::commands::ClearCursor* release_clearcursor(); + ::dapi::commands::ClearCursor* mutable_clearcursor(); + void set_allocated_clearcursor(::dapi::commands::ClearCursor* value); + void unsafe_arena_set_allocated_clearcursor(::dapi::commands::ClearCursor* value); + ::dapi::commands::ClearCursor* unsafe_arena_release_clearcursor(); + + private: + const ::dapi::commands::ClearCursor& _internal_clearcursor() const; + ::dapi::commands::ClearCursor* _internal_mutable_clearcursor(); + + public: + // .dapi.commands.IdentifyItem identifyItem = 33; + bool has_identifyitem() const; + private: + bool _internal_has_identifyitem() const; + + public: + void clear_identifyitem() ; + const ::dapi::commands::IdentifyItem& identifyitem() const; + PROTOBUF_NODISCARD ::dapi::commands::IdentifyItem* release_identifyitem(); + ::dapi::commands::IdentifyItem* mutable_identifyitem(); + void set_allocated_identifyitem(::dapi::commands::IdentifyItem* value); + void unsafe_arena_set_allocated_identifyitem(::dapi::commands::IdentifyItem* value); + ::dapi::commands::IdentifyItem* unsafe_arena_release_identifyitem(); + + private: + const ::dapi::commands::IdentifyItem& _internal_identifyitem() const; + ::dapi::commands::IdentifyItem* _internal_mutable_identifyitem(); + + public: + void clear_command(); + CommandCase command_case() const; + // @@protoc_insertion_point(class_scope:dapi.commands.Command) + private: + class _Internal; + void set_has_move(); + void set_has_talk(); + void set_has_option(); + void set_has_buyitem(); + void set_has_sellitem(); + void set_has_rechargeitem(); + void set_has_repairitem(); + void set_has_attackmonster(); + void set_has_attackxy(); + void set_has_operateobject(); + void set_has_usebeltitem(); + void set_has_togglecharactersheet(); + void set_has_increasestat(); + void set_has_getitem(); + void set_has_setspell(); + void set_has_castmonster(); + void set_has_castxy(); + void set_has_toggleinventory(); + void set_has_putincursor(); + void set_has_putcursoritem(); + void set_has_dropcursoritem(); + void set_has_useitem(); + void set_has_identifystoreitem(); + void set_has_cancelqtext(); + void set_has_setfps(); + void set_has_disarmtrap(); + void set_has_skillrepair(); + void set_has_skillrecharge(); + void set_has_togglemenu(); + void set_has_savegame(); + void set_has_quit(); + void set_has_clearcursor(); + void set_has_identifyitem(); + inline bool has_command() const; + inline void clear_has_command(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 33, 33, + 0, 7> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Command& from_msg); + union CommandUnion { + constexpr CommandUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::dapi::commands::Move* move_; + ::dapi::commands::Talk* talk_; + ::dapi::commands::SelectStoreOption* option_; + ::dapi::commands::BuyItem* buyitem_; + ::dapi::commands::SellItem* sellitem_; + ::dapi::commands::RechargeItem* rechargeitem_; + ::dapi::commands::RepairItem* repairitem_; + ::dapi::commands::AttackMonster* attackmonster_; + ::dapi::commands::AttackXY* attackxy_; + ::dapi::commands::OperateObject* operateobject_; + ::dapi::commands::UseBeltItem* usebeltitem_; + ::dapi::commands::ToggleCharacterSheet* togglecharactersheet_; + ::dapi::commands::IncreaseStat* increasestat_; + ::dapi::commands::GetItem* getitem_; + ::dapi::commands::SetSpell* setspell_; + ::dapi::commands::CastMonster* castmonster_; + ::dapi::commands::CastXY* castxy_; + ::dapi::commands::ToggleInventory* toggleinventory_; + ::dapi::commands::PutInCursor* putincursor_; + ::dapi::commands::PutCursorItem* putcursoritem_; + ::dapi::commands::DropCursorItem* dropcursoritem_; + ::dapi::commands::UseItem* useitem_; + ::dapi::commands::IdentifyStoreItem* identifystoreitem_; + ::dapi::commands::CancelQText* cancelqtext_; + ::dapi::commands::SetFPS* setfps_; + ::dapi::commands::DisarmTrap* disarmtrap_; + ::dapi::commands::SkillRepair* skillrepair_; + ::dapi::commands::SkillRecharge* skillrecharge_; + ::dapi::commands::ToggleMenu* togglemenu_; + ::dapi::commands::SaveGame* savegame_; + ::dapi::commands::Quit* quit_; + ::dapi::commands::ClearCursor* clearcursor_; + ::dapi::commands::IdentifyItem* identifyitem_; + } command_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_command_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// SetFPS + +// uint32 FPS = 1; +inline void SetFPS::clear_fps() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.fps_ = 0u; +} +inline ::uint32_t SetFPS::fps() const { + // @@protoc_insertion_point(field_get:dapi.commands.SetFPS.FPS) + return _internal_fps(); +} +inline void SetFPS::set_fps(::uint32_t value) { + _internal_set_fps(value); + // @@protoc_insertion_point(field_set:dapi.commands.SetFPS.FPS) +} +inline ::uint32_t SetFPS::_internal_fps() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.fps_; +} +inline void SetFPS::_internal_set_fps(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.fps_ = value; +} + +// ------------------------------------------------------------------- + +// CancelQText + +// ------------------------------------------------------------------- + +// Move + +// uint32 type = 1; +inline void Move::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0u; +} +inline ::uint32_t Move::type() const { + // @@protoc_insertion_point(field_get:dapi.commands.Move.type) + return _internal_type(); +} +inline void Move::set_type(::uint32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.commands.Move.type) +} +inline ::uint32_t Move::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void Move::_internal_set_type(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// uint32 targetX = 2; +inline void Move::clear_targetx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targetx_ = 0u; +} +inline ::uint32_t Move::targetx() const { + // @@protoc_insertion_point(field_get:dapi.commands.Move.targetX) + return _internal_targetx(); +} +inline void Move::set_targetx(::uint32_t value) { + _internal_set_targetx(value); + // @@protoc_insertion_point(field_set:dapi.commands.Move.targetX) +} +inline ::uint32_t Move::_internal_targetx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.targetx_; +} +inline void Move::_internal_set_targetx(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targetx_ = value; +} + +// uint32 targetY = 3; +inline void Move::clear_targety() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targety_ = 0u; +} +inline ::uint32_t Move::targety() const { + // @@protoc_insertion_point(field_get:dapi.commands.Move.targetY) + return _internal_targety(); +} +inline void Move::set_targety(::uint32_t value) { + _internal_set_targety(value); + // @@protoc_insertion_point(field_set:dapi.commands.Move.targetY) +} +inline ::uint32_t Move::_internal_targety() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.targety_; +} +inline void Move::_internal_set_targety(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targety_ = value; +} + +// ------------------------------------------------------------------- + +// Talk + +// uint32 targetX = 1; +inline void Talk::clear_targetx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targetx_ = 0u; +} +inline ::uint32_t Talk::targetx() const { + // @@protoc_insertion_point(field_get:dapi.commands.Talk.targetX) + return _internal_targetx(); +} +inline void Talk::set_targetx(::uint32_t value) { + _internal_set_targetx(value); + // @@protoc_insertion_point(field_set:dapi.commands.Talk.targetX) +} +inline ::uint32_t Talk::_internal_targetx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.targetx_; +} +inline void Talk::_internal_set_targetx(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targetx_ = value; +} + +// uint32 targetY = 2; +inline void Talk::clear_targety() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targety_ = 0u; +} +inline ::uint32_t Talk::targety() const { + // @@protoc_insertion_point(field_get:dapi.commands.Talk.targetY) + return _internal_targety(); +} +inline void Talk::set_targety(::uint32_t value) { + _internal_set_targety(value); + // @@protoc_insertion_point(field_set:dapi.commands.Talk.targetY) +} +inline ::uint32_t Talk::_internal_targety() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.targety_; +} +inline void Talk::_internal_set_targety(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.targety_ = value; +} + +// ------------------------------------------------------------------- + +// SelectStoreOption + +// uint32 option = 1; +inline void SelectStoreOption::clear_option() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.option_ = 0u; +} +inline ::uint32_t SelectStoreOption::option() const { + // @@protoc_insertion_point(field_get:dapi.commands.SelectStoreOption.option) + return _internal_option(); +} +inline void SelectStoreOption::set_option(::uint32_t value) { + _internal_set_option(value); + // @@protoc_insertion_point(field_set:dapi.commands.SelectStoreOption.option) +} +inline ::uint32_t SelectStoreOption::_internal_option() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.option_; +} +inline void SelectStoreOption::_internal_set_option(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.option_ = value; +} + +// ------------------------------------------------------------------- + +// BuyItem + +// uint32 ID = 1; +inline void BuyItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t BuyItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.BuyItem.ID) + return _internal_id(); +} +inline void BuyItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.BuyItem.ID) +} +inline ::uint32_t BuyItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void BuyItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// SellItem + +// uint32 ID = 1; +inline void SellItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t SellItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.SellItem.ID) + return _internal_id(); +} +inline void SellItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.SellItem.ID) +} +inline ::uint32_t SellItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void SellItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// RechargeItem + +// uint32 ID = 1; +inline void RechargeItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t RechargeItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.RechargeItem.ID) + return _internal_id(); +} +inline void RechargeItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.RechargeItem.ID) +} +inline ::uint32_t RechargeItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void RechargeItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// RepairItem + +// uint32 ID = 1; +inline void RepairItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t RepairItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.RepairItem.ID) + return _internal_id(); +} +inline void RepairItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.RepairItem.ID) +} +inline ::uint32_t RepairItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void RepairItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// AttackMonster + +// uint32 index = 1; +inline void AttackMonster::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t AttackMonster::index() const { + // @@protoc_insertion_point(field_get:dapi.commands.AttackMonster.index) + return _internal_index(); +} +inline void AttackMonster::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.commands.AttackMonster.index) +} +inline ::uint32_t AttackMonster::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void AttackMonster::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// ------------------------------------------------------------------- + +// AttackXY + +// sint32 x = 1; +inline void AttackXY::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0; +} +inline ::int32_t AttackXY::x() const { + // @@protoc_insertion_point(field_get:dapi.commands.AttackXY.x) + return _internal_x(); +} +inline void AttackXY::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.commands.AttackXY.x) +} +inline ::int32_t AttackXY::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void AttackXY::_internal_set_x(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// sint32 y = 2; +inline void AttackXY::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0; +} +inline ::int32_t AttackXY::y() const { + // @@protoc_insertion_point(field_get:dapi.commands.AttackXY.y) + return _internal_y(); +} +inline void AttackXY::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.commands.AttackXY.y) +} +inline ::int32_t AttackXY::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void AttackXY::_internal_set_y(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// ------------------------------------------------------------------- + +// OperateObject + +// uint32 index = 1; +inline void OperateObject::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t OperateObject::index() const { + // @@protoc_insertion_point(field_get:dapi.commands.OperateObject.index) + return _internal_index(); +} +inline void OperateObject::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.commands.OperateObject.index) +} +inline ::uint32_t OperateObject::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void OperateObject::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// ------------------------------------------------------------------- + +// UseBeltItem + +// uint32 slot = 1; +inline void UseBeltItem::clear_slot() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_ = 0u; +} +inline ::uint32_t UseBeltItem::slot() const { + // @@protoc_insertion_point(field_get:dapi.commands.UseBeltItem.slot) + return _internal_slot(); +} +inline void UseBeltItem::set_slot(::uint32_t value) { + _internal_set_slot(value); + // @@protoc_insertion_point(field_set:dapi.commands.UseBeltItem.slot) +} +inline ::uint32_t UseBeltItem::_internal_slot() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.slot_; +} +inline void UseBeltItem::_internal_set_slot(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.slot_ = value; +} + +// ------------------------------------------------------------------- + +// ToggleCharacterSheet + +// ------------------------------------------------------------------- + +// IncreaseStat + +// uint32 stat = 1; +inline void IncreaseStat::clear_stat() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stat_ = 0u; +} +inline ::uint32_t IncreaseStat::stat() const { + // @@protoc_insertion_point(field_get:dapi.commands.IncreaseStat.stat) + return _internal_stat(); +} +inline void IncreaseStat::set_stat(::uint32_t value) { + _internal_set_stat(value); + // @@protoc_insertion_point(field_set:dapi.commands.IncreaseStat.stat) +} +inline ::uint32_t IncreaseStat::_internal_stat() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.stat_; +} +inline void IncreaseStat::_internal_set_stat(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stat_ = value; +} + +// ------------------------------------------------------------------- + +// GetItem + +// uint32 ID = 1; +inline void GetItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t GetItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.GetItem.ID) + return _internal_id(); +} +inline void GetItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.GetItem.ID) +} +inline ::uint32_t GetItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void GetItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// SetSpell + +// sint32 spellID = 1; +inline void SetSpell::clear_spellid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.spellid_ = 0; +} +inline ::int32_t SetSpell::spellid() const { + // @@protoc_insertion_point(field_get:dapi.commands.SetSpell.spellID) + return _internal_spellid(); +} +inline void SetSpell::set_spellid(::int32_t value) { + _internal_set_spellid(value); + // @@protoc_insertion_point(field_set:dapi.commands.SetSpell.spellID) +} +inline ::int32_t SetSpell::_internal_spellid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.spellid_; +} +inline void SetSpell::_internal_set_spellid(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.spellid_ = value; +} + +// sint32 spellType = 2; +inline void SetSpell::clear_spelltype() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.spelltype_ = 0; +} +inline ::int32_t SetSpell::spelltype() const { + // @@protoc_insertion_point(field_get:dapi.commands.SetSpell.spellType) + return _internal_spelltype(); +} +inline void SetSpell::set_spelltype(::int32_t value) { + _internal_set_spelltype(value); + // @@protoc_insertion_point(field_set:dapi.commands.SetSpell.spellType) +} +inline ::int32_t SetSpell::_internal_spelltype() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.spelltype_; +} +inline void SetSpell::_internal_set_spelltype(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.spelltype_ = value; +} + +// ------------------------------------------------------------------- + +// CastMonster + +// uint32 index = 1; +inline void CastMonster::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t CastMonster::index() const { + // @@protoc_insertion_point(field_get:dapi.commands.CastMonster.index) + return _internal_index(); +} +inline void CastMonster::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.commands.CastMonster.index) +} +inline ::uint32_t CastMonster::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void CastMonster::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// ------------------------------------------------------------------- + +// CastXY + +// sint32 x = 1; +inline void CastXY::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0; +} +inline ::int32_t CastXY::x() const { + // @@protoc_insertion_point(field_get:dapi.commands.CastXY.x) + return _internal_x(); +} +inline void CastXY::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.commands.CastXY.x) +} +inline ::int32_t CastXY::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void CastXY::_internal_set_x(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// sint32 y = 2; +inline void CastXY::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0; +} +inline ::int32_t CastXY::y() const { + // @@protoc_insertion_point(field_get:dapi.commands.CastXY.y) + return _internal_y(); +} +inline void CastXY::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.commands.CastXY.y) +} +inline ::int32_t CastXY::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void CastXY::_internal_set_y(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// ------------------------------------------------------------------- + +// ToggleInventory + +// ------------------------------------------------------------------- + +// PutInCursor + +// uint32 ID = 1; +inline void PutInCursor::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t PutInCursor::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.PutInCursor.ID) + return _internal_id(); +} +inline void PutInCursor::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.PutInCursor.ID) +} +inline ::uint32_t PutInCursor::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void PutInCursor::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// PutCursorItem + +// sint32 target = 1; +inline void PutCursorItem::clear_target() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.target_ = 0; +} +inline ::int32_t PutCursorItem::target() const { + // @@protoc_insertion_point(field_get:dapi.commands.PutCursorItem.target) + return _internal_target(); +} +inline void PutCursorItem::set_target(::int32_t value) { + _internal_set_target(value); + // @@protoc_insertion_point(field_set:dapi.commands.PutCursorItem.target) +} +inline ::int32_t PutCursorItem::_internal_target() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.target_; +} +inline void PutCursorItem::_internal_set_target(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.target_ = value; +} + +// ------------------------------------------------------------------- + +// DropCursorItem + +// ------------------------------------------------------------------- + +// UseItem + +// uint32 ID = 1; +inline void UseItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t UseItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.UseItem.ID) + return _internal_id(); +} +inline void UseItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.UseItem.ID) +} +inline ::uint32_t UseItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void UseItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// IdentifyStoreItem + +// uint32 ID = 1; +inline void IdentifyStoreItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t IdentifyStoreItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.IdentifyStoreItem.ID) + return _internal_id(); +} +inline void IdentifyStoreItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.IdentifyStoreItem.ID) +} +inline ::uint32_t IdentifyStoreItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void IdentifyStoreItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// DisarmTrap + +// uint32 index = 1; +inline void DisarmTrap::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t DisarmTrap::index() const { + // @@protoc_insertion_point(field_get:dapi.commands.DisarmTrap.index) + return _internal_index(); +} +inline void DisarmTrap::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.commands.DisarmTrap.index) +} +inline ::uint32_t DisarmTrap::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void DisarmTrap::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// ------------------------------------------------------------------- + +// SkillRepair + +// uint32 ID = 1; +inline void SkillRepair::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t SkillRepair::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.SkillRepair.ID) + return _internal_id(); +} +inline void SkillRepair::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.SkillRepair.ID) +} +inline ::uint32_t SkillRepair::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void SkillRepair::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// SkillRecharge + +// uint32 ID = 1; +inline void SkillRecharge::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t SkillRecharge::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.SkillRecharge.ID) + return _internal_id(); +} +inline void SkillRecharge::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.SkillRecharge.ID) +} +inline ::uint32_t SkillRecharge::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void SkillRecharge::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// ToggleMenu + +// ------------------------------------------------------------------- + +// SaveGame + +// ------------------------------------------------------------------- + +// Quit + +// ------------------------------------------------------------------- + +// ClearCursor + +// ------------------------------------------------------------------- + +// IdentifyItem + +// uint32 ID = 1; +inline void IdentifyItem::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t IdentifyItem::id() const { + // @@protoc_insertion_point(field_get:dapi.commands.IdentifyItem.ID) + return _internal_id(); +} +inline void IdentifyItem::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.commands.IdentifyItem.ID) +} +inline ::uint32_t IdentifyItem::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void IdentifyItem::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// ------------------------------------------------------------------- + +// Command + +// .dapi.commands.Move move = 1; +inline bool Command::has_move() const { + return command_case() == kMove; +} +inline bool Command::_internal_has_move() const { + return command_case() == kMove; +} +inline void Command::set_has_move() { + _impl_._oneof_case_[0] = kMove; +} +inline void Command::clear_move() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kMove) { + if (GetArena() == nullptr) { + delete _impl_.command_.move_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.move_ != nullptr) { + _impl_.command_.move_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::Move* Command::release_move() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.move) + if (command_case() == kMove) { + clear_has_command(); + auto* temp = _impl_.command_.move_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.move_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::Move& Command::_internal_move() const { + return command_case() == kMove ? *_impl_.command_.move_ : reinterpret_cast<::dapi::commands::Move&>(::dapi::commands::_Move_default_instance_); +} +inline const ::dapi::commands::Move& Command::move() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.move) + return _internal_move(); +} +inline ::dapi::commands::Move* Command::unsafe_arena_release_move() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.move) + if (command_case() == kMove) { + clear_has_command(); + auto* temp = _impl_.command_.move_; + _impl_.command_.move_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_move(::dapi::commands::Move* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_move(); + _impl_.command_.move_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.move) +} +inline ::dapi::commands::Move* Command::_internal_mutable_move() { + if (command_case() != kMove) { + clear_command(); + set_has_move(); + _impl_.command_.move_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Move>(GetArena()); + } + return _impl_.command_.move_; +} +inline ::dapi::commands::Move* Command::mutable_move() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::Move* _msg = _internal_mutable_move(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.move) + return _msg; +} + +// .dapi.commands.Talk talk = 2; +inline bool Command::has_talk() const { + return command_case() == kTalk; +} +inline bool Command::_internal_has_talk() const { + return command_case() == kTalk; +} +inline void Command::set_has_talk() { + _impl_._oneof_case_[0] = kTalk; +} +inline void Command::clear_talk() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kTalk) { + if (GetArena() == nullptr) { + delete _impl_.command_.talk_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.talk_ != nullptr) { + _impl_.command_.talk_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::Talk* Command::release_talk() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.talk) + if (command_case() == kTalk) { + clear_has_command(); + auto* temp = _impl_.command_.talk_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.talk_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::Talk& Command::_internal_talk() const { + return command_case() == kTalk ? *_impl_.command_.talk_ : reinterpret_cast<::dapi::commands::Talk&>(::dapi::commands::_Talk_default_instance_); +} +inline const ::dapi::commands::Talk& Command::talk() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.talk) + return _internal_talk(); +} +inline ::dapi::commands::Talk* Command::unsafe_arena_release_talk() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.talk) + if (command_case() == kTalk) { + clear_has_command(); + auto* temp = _impl_.command_.talk_; + _impl_.command_.talk_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_talk(::dapi::commands::Talk* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_talk(); + _impl_.command_.talk_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.talk) +} +inline ::dapi::commands::Talk* Command::_internal_mutable_talk() { + if (command_case() != kTalk) { + clear_command(); + set_has_talk(); + _impl_.command_.talk_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Talk>(GetArena()); + } + return _impl_.command_.talk_; +} +inline ::dapi::commands::Talk* Command::mutable_talk() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::Talk* _msg = _internal_mutable_talk(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.talk) + return _msg; +} + +// .dapi.commands.SelectStoreOption option = 3; +inline bool Command::has_option() const { + return command_case() == kOption; +} +inline bool Command::_internal_has_option() const { + return command_case() == kOption; +} +inline void Command::set_has_option() { + _impl_._oneof_case_[0] = kOption; +} +inline void Command::clear_option() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kOption) { + if (GetArena() == nullptr) { + delete _impl_.command_.option_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.option_ != nullptr) { + _impl_.command_.option_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SelectStoreOption* Command::release_option() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.option) + if (command_case() == kOption) { + clear_has_command(); + auto* temp = _impl_.command_.option_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.option_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SelectStoreOption& Command::_internal_option() const { + return command_case() == kOption ? *_impl_.command_.option_ : reinterpret_cast<::dapi::commands::SelectStoreOption&>(::dapi::commands::_SelectStoreOption_default_instance_); +} +inline const ::dapi::commands::SelectStoreOption& Command::option() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.option) + return _internal_option(); +} +inline ::dapi::commands::SelectStoreOption* Command::unsafe_arena_release_option() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.option) + if (command_case() == kOption) { + clear_has_command(); + auto* temp = _impl_.command_.option_; + _impl_.command_.option_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_option(::dapi::commands::SelectStoreOption* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_option(); + _impl_.command_.option_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.option) +} +inline ::dapi::commands::SelectStoreOption* Command::_internal_mutable_option() { + if (command_case() != kOption) { + clear_command(); + set_has_option(); + _impl_.command_.option_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SelectStoreOption>(GetArena()); + } + return _impl_.command_.option_; +} +inline ::dapi::commands::SelectStoreOption* Command::mutable_option() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SelectStoreOption* _msg = _internal_mutable_option(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.option) + return _msg; +} + +// .dapi.commands.BuyItem buyItem = 4; +inline bool Command::has_buyitem() const { + return command_case() == kBuyItem; +} +inline bool Command::_internal_has_buyitem() const { + return command_case() == kBuyItem; +} +inline void Command::set_has_buyitem() { + _impl_._oneof_case_[0] = kBuyItem; +} +inline void Command::clear_buyitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kBuyItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.buyitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.buyitem_ != nullptr) { + _impl_.command_.buyitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::BuyItem* Command::release_buyitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.buyItem) + if (command_case() == kBuyItem) { + clear_has_command(); + auto* temp = _impl_.command_.buyitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.buyitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::BuyItem& Command::_internal_buyitem() const { + return command_case() == kBuyItem ? *_impl_.command_.buyitem_ : reinterpret_cast<::dapi::commands::BuyItem&>(::dapi::commands::_BuyItem_default_instance_); +} +inline const ::dapi::commands::BuyItem& Command::buyitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.buyItem) + return _internal_buyitem(); +} +inline ::dapi::commands::BuyItem* Command::unsafe_arena_release_buyitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.buyItem) + if (command_case() == kBuyItem) { + clear_has_command(); + auto* temp = _impl_.command_.buyitem_; + _impl_.command_.buyitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_buyitem(::dapi::commands::BuyItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_buyitem(); + _impl_.command_.buyitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.buyItem) +} +inline ::dapi::commands::BuyItem* Command::_internal_mutable_buyitem() { + if (command_case() != kBuyItem) { + clear_command(); + set_has_buyitem(); + _impl_.command_.buyitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::BuyItem>(GetArena()); + } + return _impl_.command_.buyitem_; +} +inline ::dapi::commands::BuyItem* Command::mutable_buyitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::BuyItem* _msg = _internal_mutable_buyitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.buyItem) + return _msg; +} + +// .dapi.commands.SellItem sellItem = 5; +inline bool Command::has_sellitem() const { + return command_case() == kSellItem; +} +inline bool Command::_internal_has_sellitem() const { + return command_case() == kSellItem; +} +inline void Command::set_has_sellitem() { + _impl_._oneof_case_[0] = kSellItem; +} +inline void Command::clear_sellitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSellItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.sellitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.sellitem_ != nullptr) { + _impl_.command_.sellitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SellItem* Command::release_sellitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.sellItem) + if (command_case() == kSellItem) { + clear_has_command(); + auto* temp = _impl_.command_.sellitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.sellitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SellItem& Command::_internal_sellitem() const { + return command_case() == kSellItem ? *_impl_.command_.sellitem_ : reinterpret_cast<::dapi::commands::SellItem&>(::dapi::commands::_SellItem_default_instance_); +} +inline const ::dapi::commands::SellItem& Command::sellitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.sellItem) + return _internal_sellitem(); +} +inline ::dapi::commands::SellItem* Command::unsafe_arena_release_sellitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.sellItem) + if (command_case() == kSellItem) { + clear_has_command(); + auto* temp = _impl_.command_.sellitem_; + _impl_.command_.sellitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_sellitem(::dapi::commands::SellItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_sellitem(); + _impl_.command_.sellitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.sellItem) +} +inline ::dapi::commands::SellItem* Command::_internal_mutable_sellitem() { + if (command_case() != kSellItem) { + clear_command(); + set_has_sellitem(); + _impl_.command_.sellitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SellItem>(GetArena()); + } + return _impl_.command_.sellitem_; +} +inline ::dapi::commands::SellItem* Command::mutable_sellitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SellItem* _msg = _internal_mutable_sellitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.sellItem) + return _msg; +} + +// .dapi.commands.RechargeItem rechargeItem = 6; +inline bool Command::has_rechargeitem() const { + return command_case() == kRechargeItem; +} +inline bool Command::_internal_has_rechargeitem() const { + return command_case() == kRechargeItem; +} +inline void Command::set_has_rechargeitem() { + _impl_._oneof_case_[0] = kRechargeItem; +} +inline void Command::clear_rechargeitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kRechargeItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.rechargeitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.rechargeitem_ != nullptr) { + _impl_.command_.rechargeitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::RechargeItem* Command::release_rechargeitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.rechargeItem) + if (command_case() == kRechargeItem) { + clear_has_command(); + auto* temp = _impl_.command_.rechargeitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.rechargeitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::RechargeItem& Command::_internal_rechargeitem() const { + return command_case() == kRechargeItem ? *_impl_.command_.rechargeitem_ : reinterpret_cast<::dapi::commands::RechargeItem&>(::dapi::commands::_RechargeItem_default_instance_); +} +inline const ::dapi::commands::RechargeItem& Command::rechargeitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.rechargeItem) + return _internal_rechargeitem(); +} +inline ::dapi::commands::RechargeItem* Command::unsafe_arena_release_rechargeitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.rechargeItem) + if (command_case() == kRechargeItem) { + clear_has_command(); + auto* temp = _impl_.command_.rechargeitem_; + _impl_.command_.rechargeitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_rechargeitem(::dapi::commands::RechargeItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_rechargeitem(); + _impl_.command_.rechargeitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.rechargeItem) +} +inline ::dapi::commands::RechargeItem* Command::_internal_mutable_rechargeitem() { + if (command_case() != kRechargeItem) { + clear_command(); + set_has_rechargeitem(); + _impl_.command_.rechargeitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::RechargeItem>(GetArena()); + } + return _impl_.command_.rechargeitem_; +} +inline ::dapi::commands::RechargeItem* Command::mutable_rechargeitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::RechargeItem* _msg = _internal_mutable_rechargeitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.rechargeItem) + return _msg; +} + +// .dapi.commands.RepairItem repairItem = 7; +inline bool Command::has_repairitem() const { + return command_case() == kRepairItem; +} +inline bool Command::_internal_has_repairitem() const { + return command_case() == kRepairItem; +} +inline void Command::set_has_repairitem() { + _impl_._oneof_case_[0] = kRepairItem; +} +inline void Command::clear_repairitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kRepairItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.repairitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.repairitem_ != nullptr) { + _impl_.command_.repairitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::RepairItem* Command::release_repairitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.repairItem) + if (command_case() == kRepairItem) { + clear_has_command(); + auto* temp = _impl_.command_.repairitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.repairitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::RepairItem& Command::_internal_repairitem() const { + return command_case() == kRepairItem ? *_impl_.command_.repairitem_ : reinterpret_cast<::dapi::commands::RepairItem&>(::dapi::commands::_RepairItem_default_instance_); +} +inline const ::dapi::commands::RepairItem& Command::repairitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.repairItem) + return _internal_repairitem(); +} +inline ::dapi::commands::RepairItem* Command::unsafe_arena_release_repairitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.repairItem) + if (command_case() == kRepairItem) { + clear_has_command(); + auto* temp = _impl_.command_.repairitem_; + _impl_.command_.repairitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_repairitem(::dapi::commands::RepairItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_repairitem(); + _impl_.command_.repairitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.repairItem) +} +inline ::dapi::commands::RepairItem* Command::_internal_mutable_repairitem() { + if (command_case() != kRepairItem) { + clear_command(); + set_has_repairitem(); + _impl_.command_.repairitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::RepairItem>(GetArena()); + } + return _impl_.command_.repairitem_; +} +inline ::dapi::commands::RepairItem* Command::mutable_repairitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::RepairItem* _msg = _internal_mutable_repairitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.repairItem) + return _msg; +} + +// .dapi.commands.AttackMonster attackMonster = 8; +inline bool Command::has_attackmonster() const { + return command_case() == kAttackMonster; +} +inline bool Command::_internal_has_attackmonster() const { + return command_case() == kAttackMonster; +} +inline void Command::set_has_attackmonster() { + _impl_._oneof_case_[0] = kAttackMonster; +} +inline void Command::clear_attackmonster() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kAttackMonster) { + if (GetArena() == nullptr) { + delete _impl_.command_.attackmonster_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.attackmonster_ != nullptr) { + _impl_.command_.attackmonster_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::AttackMonster* Command::release_attackmonster() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.attackMonster) + if (command_case() == kAttackMonster) { + clear_has_command(); + auto* temp = _impl_.command_.attackmonster_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.attackmonster_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::AttackMonster& Command::_internal_attackmonster() const { + return command_case() == kAttackMonster ? *_impl_.command_.attackmonster_ : reinterpret_cast<::dapi::commands::AttackMonster&>(::dapi::commands::_AttackMonster_default_instance_); +} +inline const ::dapi::commands::AttackMonster& Command::attackmonster() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.attackMonster) + return _internal_attackmonster(); +} +inline ::dapi::commands::AttackMonster* Command::unsafe_arena_release_attackmonster() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.attackMonster) + if (command_case() == kAttackMonster) { + clear_has_command(); + auto* temp = _impl_.command_.attackmonster_; + _impl_.command_.attackmonster_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_attackmonster(::dapi::commands::AttackMonster* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_attackmonster(); + _impl_.command_.attackmonster_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.attackMonster) +} +inline ::dapi::commands::AttackMonster* Command::_internal_mutable_attackmonster() { + if (command_case() != kAttackMonster) { + clear_command(); + set_has_attackmonster(); + _impl_.command_.attackmonster_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::AttackMonster>(GetArena()); + } + return _impl_.command_.attackmonster_; +} +inline ::dapi::commands::AttackMonster* Command::mutable_attackmonster() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::AttackMonster* _msg = _internal_mutable_attackmonster(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.attackMonster) + return _msg; +} + +// .dapi.commands.AttackXY attackXY = 9; +inline bool Command::has_attackxy() const { + return command_case() == kAttackXY; +} +inline bool Command::_internal_has_attackxy() const { + return command_case() == kAttackXY; +} +inline void Command::set_has_attackxy() { + _impl_._oneof_case_[0] = kAttackXY; +} +inline void Command::clear_attackxy() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kAttackXY) { + if (GetArena() == nullptr) { + delete _impl_.command_.attackxy_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.attackxy_ != nullptr) { + _impl_.command_.attackxy_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::AttackXY* Command::release_attackxy() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.attackXY) + if (command_case() == kAttackXY) { + clear_has_command(); + auto* temp = _impl_.command_.attackxy_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.attackxy_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::AttackXY& Command::_internal_attackxy() const { + return command_case() == kAttackXY ? *_impl_.command_.attackxy_ : reinterpret_cast<::dapi::commands::AttackXY&>(::dapi::commands::_AttackXY_default_instance_); +} +inline const ::dapi::commands::AttackXY& Command::attackxy() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.attackXY) + return _internal_attackxy(); +} +inline ::dapi::commands::AttackXY* Command::unsafe_arena_release_attackxy() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.attackXY) + if (command_case() == kAttackXY) { + clear_has_command(); + auto* temp = _impl_.command_.attackxy_; + _impl_.command_.attackxy_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_attackxy(::dapi::commands::AttackXY* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_attackxy(); + _impl_.command_.attackxy_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.attackXY) +} +inline ::dapi::commands::AttackXY* Command::_internal_mutable_attackxy() { + if (command_case() != kAttackXY) { + clear_command(); + set_has_attackxy(); + _impl_.command_.attackxy_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::AttackXY>(GetArena()); + } + return _impl_.command_.attackxy_; +} +inline ::dapi::commands::AttackXY* Command::mutable_attackxy() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::AttackXY* _msg = _internal_mutable_attackxy(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.attackXY) + return _msg; +} + +// .dapi.commands.OperateObject operateObject = 10; +inline bool Command::has_operateobject() const { + return command_case() == kOperateObject; +} +inline bool Command::_internal_has_operateobject() const { + return command_case() == kOperateObject; +} +inline void Command::set_has_operateobject() { + _impl_._oneof_case_[0] = kOperateObject; +} +inline void Command::clear_operateobject() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kOperateObject) { + if (GetArena() == nullptr) { + delete _impl_.command_.operateobject_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.operateobject_ != nullptr) { + _impl_.command_.operateobject_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::OperateObject* Command::release_operateobject() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.operateObject) + if (command_case() == kOperateObject) { + clear_has_command(); + auto* temp = _impl_.command_.operateobject_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.operateobject_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::OperateObject& Command::_internal_operateobject() const { + return command_case() == kOperateObject ? *_impl_.command_.operateobject_ : reinterpret_cast<::dapi::commands::OperateObject&>(::dapi::commands::_OperateObject_default_instance_); +} +inline const ::dapi::commands::OperateObject& Command::operateobject() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.operateObject) + return _internal_operateobject(); +} +inline ::dapi::commands::OperateObject* Command::unsafe_arena_release_operateobject() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.operateObject) + if (command_case() == kOperateObject) { + clear_has_command(); + auto* temp = _impl_.command_.operateobject_; + _impl_.command_.operateobject_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_operateobject(::dapi::commands::OperateObject* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_operateobject(); + _impl_.command_.operateobject_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.operateObject) +} +inline ::dapi::commands::OperateObject* Command::_internal_mutable_operateobject() { + if (command_case() != kOperateObject) { + clear_command(); + set_has_operateobject(); + _impl_.command_.operateobject_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::OperateObject>(GetArena()); + } + return _impl_.command_.operateobject_; +} +inline ::dapi::commands::OperateObject* Command::mutable_operateobject() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::OperateObject* _msg = _internal_mutable_operateobject(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.operateObject) + return _msg; +} + +// .dapi.commands.UseBeltItem useBeltItem = 11; +inline bool Command::has_usebeltitem() const { + return command_case() == kUseBeltItem; +} +inline bool Command::_internal_has_usebeltitem() const { + return command_case() == kUseBeltItem; +} +inline void Command::set_has_usebeltitem() { + _impl_._oneof_case_[0] = kUseBeltItem; +} +inline void Command::clear_usebeltitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kUseBeltItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.usebeltitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.usebeltitem_ != nullptr) { + _impl_.command_.usebeltitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::UseBeltItem* Command::release_usebeltitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.useBeltItem) + if (command_case() == kUseBeltItem) { + clear_has_command(); + auto* temp = _impl_.command_.usebeltitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.usebeltitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::UseBeltItem& Command::_internal_usebeltitem() const { + return command_case() == kUseBeltItem ? *_impl_.command_.usebeltitem_ : reinterpret_cast<::dapi::commands::UseBeltItem&>(::dapi::commands::_UseBeltItem_default_instance_); +} +inline const ::dapi::commands::UseBeltItem& Command::usebeltitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.useBeltItem) + return _internal_usebeltitem(); +} +inline ::dapi::commands::UseBeltItem* Command::unsafe_arena_release_usebeltitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.useBeltItem) + if (command_case() == kUseBeltItem) { + clear_has_command(); + auto* temp = _impl_.command_.usebeltitem_; + _impl_.command_.usebeltitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_usebeltitem(); + _impl_.command_.usebeltitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.useBeltItem) +} +inline ::dapi::commands::UseBeltItem* Command::_internal_mutable_usebeltitem() { + if (command_case() != kUseBeltItem) { + clear_command(); + set_has_usebeltitem(); + _impl_.command_.usebeltitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::UseBeltItem>(GetArena()); + } + return _impl_.command_.usebeltitem_; +} +inline ::dapi::commands::UseBeltItem* Command::mutable_usebeltitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::UseBeltItem* _msg = _internal_mutable_usebeltitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.useBeltItem) + return _msg; +} + +// .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; +inline bool Command::has_togglecharactersheet() const { + return command_case() == kToggleCharacterSheet; +} +inline bool Command::_internal_has_togglecharactersheet() const { + return command_case() == kToggleCharacterSheet; +} +inline void Command::set_has_togglecharactersheet() { + _impl_._oneof_case_[0] = kToggleCharacterSheet; +} +inline void Command::clear_togglecharactersheet() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kToggleCharacterSheet) { + if (GetArena() == nullptr) { + delete _impl_.command_.togglecharactersheet_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.togglecharactersheet_ != nullptr) { + _impl_.command_.togglecharactersheet_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::ToggleCharacterSheet* Command::release_togglecharactersheet() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleCharacterSheet) + if (command_case() == kToggleCharacterSheet) { + clear_has_command(); + auto* temp = _impl_.command_.togglecharactersheet_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.togglecharactersheet_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::ToggleCharacterSheet& Command::_internal_togglecharactersheet() const { + return command_case() == kToggleCharacterSheet ? *_impl_.command_.togglecharactersheet_ : reinterpret_cast<::dapi::commands::ToggleCharacterSheet&>(::dapi::commands::_ToggleCharacterSheet_default_instance_); +} +inline const ::dapi::commands::ToggleCharacterSheet& Command::togglecharactersheet() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleCharacterSheet) + return _internal_togglecharactersheet(); +} +inline ::dapi::commands::ToggleCharacterSheet* Command::unsafe_arena_release_togglecharactersheet() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleCharacterSheet) + if (command_case() == kToggleCharacterSheet) { + clear_has_command(); + auto* temp = _impl_.command_.togglecharactersheet_; + _impl_.command_.togglecharactersheet_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_togglecharactersheet(); + _impl_.command_.togglecharactersheet_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleCharacterSheet) +} +inline ::dapi::commands::ToggleCharacterSheet* Command::_internal_mutable_togglecharactersheet() { + if (command_case() != kToggleCharacterSheet) { + clear_command(); + set_has_togglecharactersheet(); + _impl_.command_.togglecharactersheet_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleCharacterSheet>(GetArena()); + } + return _impl_.command_.togglecharactersheet_; +} +inline ::dapi::commands::ToggleCharacterSheet* Command::mutable_togglecharactersheet() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::ToggleCharacterSheet* _msg = _internal_mutable_togglecharactersheet(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleCharacterSheet) + return _msg; +} + +// .dapi.commands.IncreaseStat increaseStat = 13; +inline bool Command::has_increasestat() const { + return command_case() == kIncreaseStat; +} +inline bool Command::_internal_has_increasestat() const { + return command_case() == kIncreaseStat; +} +inline void Command::set_has_increasestat() { + _impl_._oneof_case_[0] = kIncreaseStat; +} +inline void Command::clear_increasestat() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kIncreaseStat) { + if (GetArena() == nullptr) { + delete _impl_.command_.increasestat_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.increasestat_ != nullptr) { + _impl_.command_.increasestat_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::IncreaseStat* Command::release_increasestat() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.increaseStat) + if (command_case() == kIncreaseStat) { + clear_has_command(); + auto* temp = _impl_.command_.increasestat_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.increasestat_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::IncreaseStat& Command::_internal_increasestat() const { + return command_case() == kIncreaseStat ? *_impl_.command_.increasestat_ : reinterpret_cast<::dapi::commands::IncreaseStat&>(::dapi::commands::_IncreaseStat_default_instance_); +} +inline const ::dapi::commands::IncreaseStat& Command::increasestat() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.increaseStat) + return _internal_increasestat(); +} +inline ::dapi::commands::IncreaseStat* Command::unsafe_arena_release_increasestat() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.increaseStat) + if (command_case() == kIncreaseStat) { + clear_has_command(); + auto* temp = _impl_.command_.increasestat_; + _impl_.command_.increasestat_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_increasestat(::dapi::commands::IncreaseStat* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_increasestat(); + _impl_.command_.increasestat_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.increaseStat) +} +inline ::dapi::commands::IncreaseStat* Command::_internal_mutable_increasestat() { + if (command_case() != kIncreaseStat) { + clear_command(); + set_has_increasestat(); + _impl_.command_.increasestat_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IncreaseStat>(GetArena()); + } + return _impl_.command_.increasestat_; +} +inline ::dapi::commands::IncreaseStat* Command::mutable_increasestat() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::IncreaseStat* _msg = _internal_mutable_increasestat(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.increaseStat) + return _msg; +} + +// .dapi.commands.GetItem getItem = 14; +inline bool Command::has_getitem() const { + return command_case() == kGetItem; +} +inline bool Command::_internal_has_getitem() const { + return command_case() == kGetItem; +} +inline void Command::set_has_getitem() { + _impl_._oneof_case_[0] = kGetItem; +} +inline void Command::clear_getitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kGetItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.getitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.getitem_ != nullptr) { + _impl_.command_.getitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::GetItem* Command::release_getitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.getItem) + if (command_case() == kGetItem) { + clear_has_command(); + auto* temp = _impl_.command_.getitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.getitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::GetItem& Command::_internal_getitem() const { + return command_case() == kGetItem ? *_impl_.command_.getitem_ : reinterpret_cast<::dapi::commands::GetItem&>(::dapi::commands::_GetItem_default_instance_); +} +inline const ::dapi::commands::GetItem& Command::getitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.getItem) + return _internal_getitem(); +} +inline ::dapi::commands::GetItem* Command::unsafe_arena_release_getitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.getItem) + if (command_case() == kGetItem) { + clear_has_command(); + auto* temp = _impl_.command_.getitem_; + _impl_.command_.getitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_getitem(::dapi::commands::GetItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_getitem(); + _impl_.command_.getitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.getItem) +} +inline ::dapi::commands::GetItem* Command::_internal_mutable_getitem() { + if (command_case() != kGetItem) { + clear_command(); + set_has_getitem(); + _impl_.command_.getitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::GetItem>(GetArena()); + } + return _impl_.command_.getitem_; +} +inline ::dapi::commands::GetItem* Command::mutable_getitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::GetItem* _msg = _internal_mutable_getitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.getItem) + return _msg; +} + +// .dapi.commands.SetSpell setSpell = 15; +inline bool Command::has_setspell() const { + return command_case() == kSetSpell; +} +inline bool Command::_internal_has_setspell() const { + return command_case() == kSetSpell; +} +inline void Command::set_has_setspell() { + _impl_._oneof_case_[0] = kSetSpell; +} +inline void Command::clear_setspell() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSetSpell) { + if (GetArena() == nullptr) { + delete _impl_.command_.setspell_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.setspell_ != nullptr) { + _impl_.command_.setspell_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SetSpell* Command::release_setspell() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.setSpell) + if (command_case() == kSetSpell) { + clear_has_command(); + auto* temp = _impl_.command_.setspell_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.setspell_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SetSpell& Command::_internal_setspell() const { + return command_case() == kSetSpell ? *_impl_.command_.setspell_ : reinterpret_cast<::dapi::commands::SetSpell&>(::dapi::commands::_SetSpell_default_instance_); +} +inline const ::dapi::commands::SetSpell& Command::setspell() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.setSpell) + return _internal_setspell(); +} +inline ::dapi::commands::SetSpell* Command::unsafe_arena_release_setspell() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.setSpell) + if (command_case() == kSetSpell) { + clear_has_command(); + auto* temp = _impl_.command_.setspell_; + _impl_.command_.setspell_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_setspell(::dapi::commands::SetSpell* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_setspell(); + _impl_.command_.setspell_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.setSpell) +} +inline ::dapi::commands::SetSpell* Command::_internal_mutable_setspell() { + if (command_case() != kSetSpell) { + clear_command(); + set_has_setspell(); + _impl_.command_.setspell_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SetSpell>(GetArena()); + } + return _impl_.command_.setspell_; +} +inline ::dapi::commands::SetSpell* Command::mutable_setspell() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SetSpell* _msg = _internal_mutable_setspell(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.setSpell) + return _msg; +} + +// .dapi.commands.CastMonster castMonster = 16; +inline bool Command::has_castmonster() const { + return command_case() == kCastMonster; +} +inline bool Command::_internal_has_castmonster() const { + return command_case() == kCastMonster; +} +inline void Command::set_has_castmonster() { + _impl_._oneof_case_[0] = kCastMonster; +} +inline void Command::clear_castmonster() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kCastMonster) { + if (GetArena() == nullptr) { + delete _impl_.command_.castmonster_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.castmonster_ != nullptr) { + _impl_.command_.castmonster_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::CastMonster* Command::release_castmonster() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.castMonster) + if (command_case() == kCastMonster) { + clear_has_command(); + auto* temp = _impl_.command_.castmonster_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.castmonster_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::CastMonster& Command::_internal_castmonster() const { + return command_case() == kCastMonster ? *_impl_.command_.castmonster_ : reinterpret_cast<::dapi::commands::CastMonster&>(::dapi::commands::_CastMonster_default_instance_); +} +inline const ::dapi::commands::CastMonster& Command::castmonster() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.castMonster) + return _internal_castmonster(); +} +inline ::dapi::commands::CastMonster* Command::unsafe_arena_release_castmonster() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.castMonster) + if (command_case() == kCastMonster) { + clear_has_command(); + auto* temp = _impl_.command_.castmonster_; + _impl_.command_.castmonster_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_castmonster(::dapi::commands::CastMonster* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_castmonster(); + _impl_.command_.castmonster_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.castMonster) +} +inline ::dapi::commands::CastMonster* Command::_internal_mutable_castmonster() { + if (command_case() != kCastMonster) { + clear_command(); + set_has_castmonster(); + _impl_.command_.castmonster_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CastMonster>(GetArena()); + } + return _impl_.command_.castmonster_; +} +inline ::dapi::commands::CastMonster* Command::mutable_castmonster() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::CastMonster* _msg = _internal_mutable_castmonster(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.castMonster) + return _msg; +} + +// .dapi.commands.CastXY castXY = 17; +inline bool Command::has_castxy() const { + return command_case() == kCastXY; +} +inline bool Command::_internal_has_castxy() const { + return command_case() == kCastXY; +} +inline void Command::set_has_castxy() { + _impl_._oneof_case_[0] = kCastXY; +} +inline void Command::clear_castxy() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kCastXY) { + if (GetArena() == nullptr) { + delete _impl_.command_.castxy_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.castxy_ != nullptr) { + _impl_.command_.castxy_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::CastXY* Command::release_castxy() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.castXY) + if (command_case() == kCastXY) { + clear_has_command(); + auto* temp = _impl_.command_.castxy_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.castxy_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::CastXY& Command::_internal_castxy() const { + return command_case() == kCastXY ? *_impl_.command_.castxy_ : reinterpret_cast<::dapi::commands::CastXY&>(::dapi::commands::_CastXY_default_instance_); +} +inline const ::dapi::commands::CastXY& Command::castxy() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.castXY) + return _internal_castxy(); +} +inline ::dapi::commands::CastXY* Command::unsafe_arena_release_castxy() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.castXY) + if (command_case() == kCastXY) { + clear_has_command(); + auto* temp = _impl_.command_.castxy_; + _impl_.command_.castxy_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_castxy(::dapi::commands::CastXY* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_castxy(); + _impl_.command_.castxy_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.castXY) +} +inline ::dapi::commands::CastXY* Command::_internal_mutable_castxy() { + if (command_case() != kCastXY) { + clear_command(); + set_has_castxy(); + _impl_.command_.castxy_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CastXY>(GetArena()); + } + return _impl_.command_.castxy_; +} +inline ::dapi::commands::CastXY* Command::mutable_castxy() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::CastXY* _msg = _internal_mutable_castxy(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.castXY) + return _msg; +} + +// .dapi.commands.ToggleInventory toggleInventory = 18; +inline bool Command::has_toggleinventory() const { + return command_case() == kToggleInventory; +} +inline bool Command::_internal_has_toggleinventory() const { + return command_case() == kToggleInventory; +} +inline void Command::set_has_toggleinventory() { + _impl_._oneof_case_[0] = kToggleInventory; +} +inline void Command::clear_toggleinventory() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kToggleInventory) { + if (GetArena() == nullptr) { + delete _impl_.command_.toggleinventory_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.toggleinventory_ != nullptr) { + _impl_.command_.toggleinventory_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::ToggleInventory* Command::release_toggleinventory() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleInventory) + if (command_case() == kToggleInventory) { + clear_has_command(); + auto* temp = _impl_.command_.toggleinventory_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.toggleinventory_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::ToggleInventory& Command::_internal_toggleinventory() const { + return command_case() == kToggleInventory ? *_impl_.command_.toggleinventory_ : reinterpret_cast<::dapi::commands::ToggleInventory&>(::dapi::commands::_ToggleInventory_default_instance_); +} +inline const ::dapi::commands::ToggleInventory& Command::toggleinventory() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleInventory) + return _internal_toggleinventory(); +} +inline ::dapi::commands::ToggleInventory* Command::unsafe_arena_release_toggleinventory() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleInventory) + if (command_case() == kToggleInventory) { + clear_has_command(); + auto* temp = _impl_.command_.toggleinventory_; + _impl_.command_.toggleinventory_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_toggleinventory(); + _impl_.command_.toggleinventory_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleInventory) +} +inline ::dapi::commands::ToggleInventory* Command::_internal_mutable_toggleinventory() { + if (command_case() != kToggleInventory) { + clear_command(); + set_has_toggleinventory(); + _impl_.command_.toggleinventory_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleInventory>(GetArena()); + } + return _impl_.command_.toggleinventory_; +} +inline ::dapi::commands::ToggleInventory* Command::mutable_toggleinventory() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::ToggleInventory* _msg = _internal_mutable_toggleinventory(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleInventory) + return _msg; +} + +// .dapi.commands.PutInCursor putInCursor = 19; +inline bool Command::has_putincursor() const { + return command_case() == kPutInCursor; +} +inline bool Command::_internal_has_putincursor() const { + return command_case() == kPutInCursor; +} +inline void Command::set_has_putincursor() { + _impl_._oneof_case_[0] = kPutInCursor; +} +inline void Command::clear_putincursor() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kPutInCursor) { + if (GetArena() == nullptr) { + delete _impl_.command_.putincursor_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.putincursor_ != nullptr) { + _impl_.command_.putincursor_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::PutInCursor* Command::release_putincursor() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.putInCursor) + if (command_case() == kPutInCursor) { + clear_has_command(); + auto* temp = _impl_.command_.putincursor_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.putincursor_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::PutInCursor& Command::_internal_putincursor() const { + return command_case() == kPutInCursor ? *_impl_.command_.putincursor_ : reinterpret_cast<::dapi::commands::PutInCursor&>(::dapi::commands::_PutInCursor_default_instance_); +} +inline const ::dapi::commands::PutInCursor& Command::putincursor() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.putInCursor) + return _internal_putincursor(); +} +inline ::dapi::commands::PutInCursor* Command::unsafe_arena_release_putincursor() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.putInCursor) + if (command_case() == kPutInCursor) { + clear_has_command(); + auto* temp = _impl_.command_.putincursor_; + _impl_.command_.putincursor_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_putincursor(::dapi::commands::PutInCursor* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_putincursor(); + _impl_.command_.putincursor_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.putInCursor) +} +inline ::dapi::commands::PutInCursor* Command::_internal_mutable_putincursor() { + if (command_case() != kPutInCursor) { + clear_command(); + set_has_putincursor(); + _impl_.command_.putincursor_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::PutInCursor>(GetArena()); + } + return _impl_.command_.putincursor_; +} +inline ::dapi::commands::PutInCursor* Command::mutable_putincursor() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::PutInCursor* _msg = _internal_mutable_putincursor(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.putInCursor) + return _msg; +} + +// .dapi.commands.PutCursorItem putCursorItem = 20; +inline bool Command::has_putcursoritem() const { + return command_case() == kPutCursorItem; +} +inline bool Command::_internal_has_putcursoritem() const { + return command_case() == kPutCursorItem; +} +inline void Command::set_has_putcursoritem() { + _impl_._oneof_case_[0] = kPutCursorItem; +} +inline void Command::clear_putcursoritem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kPutCursorItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.putcursoritem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.putcursoritem_ != nullptr) { + _impl_.command_.putcursoritem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::PutCursorItem* Command::release_putcursoritem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.putCursorItem) + if (command_case() == kPutCursorItem) { + clear_has_command(); + auto* temp = _impl_.command_.putcursoritem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.putcursoritem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::PutCursorItem& Command::_internal_putcursoritem() const { + return command_case() == kPutCursorItem ? *_impl_.command_.putcursoritem_ : reinterpret_cast<::dapi::commands::PutCursorItem&>(::dapi::commands::_PutCursorItem_default_instance_); +} +inline const ::dapi::commands::PutCursorItem& Command::putcursoritem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.putCursorItem) + return _internal_putcursoritem(); +} +inline ::dapi::commands::PutCursorItem* Command::unsafe_arena_release_putcursoritem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.putCursorItem) + if (command_case() == kPutCursorItem) { + clear_has_command(); + auto* temp = _impl_.command_.putcursoritem_; + _impl_.command_.putcursoritem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_putcursoritem(); + _impl_.command_.putcursoritem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.putCursorItem) +} +inline ::dapi::commands::PutCursorItem* Command::_internal_mutable_putcursoritem() { + if (command_case() != kPutCursorItem) { + clear_command(); + set_has_putcursoritem(); + _impl_.command_.putcursoritem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::PutCursorItem>(GetArena()); + } + return _impl_.command_.putcursoritem_; +} +inline ::dapi::commands::PutCursorItem* Command::mutable_putcursoritem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::PutCursorItem* _msg = _internal_mutable_putcursoritem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.putCursorItem) + return _msg; +} + +// .dapi.commands.DropCursorItem dropCursorItem = 21; +inline bool Command::has_dropcursoritem() const { + return command_case() == kDropCursorItem; +} +inline bool Command::_internal_has_dropcursoritem() const { + return command_case() == kDropCursorItem; +} +inline void Command::set_has_dropcursoritem() { + _impl_._oneof_case_[0] = kDropCursorItem; +} +inline void Command::clear_dropcursoritem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kDropCursorItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.dropcursoritem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.dropcursoritem_ != nullptr) { + _impl_.command_.dropcursoritem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::DropCursorItem* Command::release_dropcursoritem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.dropCursorItem) + if (command_case() == kDropCursorItem) { + clear_has_command(); + auto* temp = _impl_.command_.dropcursoritem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.dropcursoritem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::DropCursorItem& Command::_internal_dropcursoritem() const { + return command_case() == kDropCursorItem ? *_impl_.command_.dropcursoritem_ : reinterpret_cast<::dapi::commands::DropCursorItem&>(::dapi::commands::_DropCursorItem_default_instance_); +} +inline const ::dapi::commands::DropCursorItem& Command::dropcursoritem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.dropCursorItem) + return _internal_dropcursoritem(); +} +inline ::dapi::commands::DropCursorItem* Command::unsafe_arena_release_dropcursoritem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.dropCursorItem) + if (command_case() == kDropCursorItem) { + clear_has_command(); + auto* temp = _impl_.command_.dropcursoritem_; + _impl_.command_.dropcursoritem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_dropcursoritem(); + _impl_.command_.dropcursoritem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.dropCursorItem) +} +inline ::dapi::commands::DropCursorItem* Command::_internal_mutable_dropcursoritem() { + if (command_case() != kDropCursorItem) { + clear_command(); + set_has_dropcursoritem(); + _impl_.command_.dropcursoritem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::DropCursorItem>(GetArena()); + } + return _impl_.command_.dropcursoritem_; +} +inline ::dapi::commands::DropCursorItem* Command::mutable_dropcursoritem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::DropCursorItem* _msg = _internal_mutable_dropcursoritem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.dropCursorItem) + return _msg; +} + +// .dapi.commands.UseItem useItem = 22; +inline bool Command::has_useitem() const { + return command_case() == kUseItem; +} +inline bool Command::_internal_has_useitem() const { + return command_case() == kUseItem; +} +inline void Command::set_has_useitem() { + _impl_._oneof_case_[0] = kUseItem; +} +inline void Command::clear_useitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kUseItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.useitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.useitem_ != nullptr) { + _impl_.command_.useitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::UseItem* Command::release_useitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.useItem) + if (command_case() == kUseItem) { + clear_has_command(); + auto* temp = _impl_.command_.useitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.useitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::UseItem& Command::_internal_useitem() const { + return command_case() == kUseItem ? *_impl_.command_.useitem_ : reinterpret_cast<::dapi::commands::UseItem&>(::dapi::commands::_UseItem_default_instance_); +} +inline const ::dapi::commands::UseItem& Command::useitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.useItem) + return _internal_useitem(); +} +inline ::dapi::commands::UseItem* Command::unsafe_arena_release_useitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.useItem) + if (command_case() == kUseItem) { + clear_has_command(); + auto* temp = _impl_.command_.useitem_; + _impl_.command_.useitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_useitem(::dapi::commands::UseItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_useitem(); + _impl_.command_.useitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.useItem) +} +inline ::dapi::commands::UseItem* Command::_internal_mutable_useitem() { + if (command_case() != kUseItem) { + clear_command(); + set_has_useitem(); + _impl_.command_.useitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::UseItem>(GetArena()); + } + return _impl_.command_.useitem_; +} +inline ::dapi::commands::UseItem* Command::mutable_useitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::UseItem* _msg = _internal_mutable_useitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.useItem) + return _msg; +} + +// .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; +inline bool Command::has_identifystoreitem() const { + return command_case() == kIdentifyStoreItem; +} +inline bool Command::_internal_has_identifystoreitem() const { + return command_case() == kIdentifyStoreItem; +} +inline void Command::set_has_identifystoreitem() { + _impl_._oneof_case_[0] = kIdentifyStoreItem; +} +inline void Command::clear_identifystoreitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kIdentifyStoreItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.identifystoreitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.identifystoreitem_ != nullptr) { + _impl_.command_.identifystoreitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::IdentifyStoreItem* Command::release_identifystoreitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.identifyStoreItem) + if (command_case() == kIdentifyStoreItem) { + clear_has_command(); + auto* temp = _impl_.command_.identifystoreitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.identifystoreitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::IdentifyStoreItem& Command::_internal_identifystoreitem() const { + return command_case() == kIdentifyStoreItem ? *_impl_.command_.identifystoreitem_ : reinterpret_cast<::dapi::commands::IdentifyStoreItem&>(::dapi::commands::_IdentifyStoreItem_default_instance_); +} +inline const ::dapi::commands::IdentifyStoreItem& Command::identifystoreitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.identifyStoreItem) + return _internal_identifystoreitem(); +} +inline ::dapi::commands::IdentifyStoreItem* Command::unsafe_arena_release_identifystoreitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.identifyStoreItem) + if (command_case() == kIdentifyStoreItem) { + clear_has_command(); + auto* temp = _impl_.command_.identifystoreitem_; + _impl_.command_.identifystoreitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_identifystoreitem(); + _impl_.command_.identifystoreitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.identifyStoreItem) +} +inline ::dapi::commands::IdentifyStoreItem* Command::_internal_mutable_identifystoreitem() { + if (command_case() != kIdentifyStoreItem) { + clear_command(); + set_has_identifystoreitem(); + _impl_.command_.identifystoreitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IdentifyStoreItem>(GetArena()); + } + return _impl_.command_.identifystoreitem_; +} +inline ::dapi::commands::IdentifyStoreItem* Command::mutable_identifystoreitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::IdentifyStoreItem* _msg = _internal_mutable_identifystoreitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.identifyStoreItem) + return _msg; +} + +// .dapi.commands.CancelQText cancelQText = 24; +inline bool Command::has_cancelqtext() const { + return command_case() == kCancelQText; +} +inline bool Command::_internal_has_cancelqtext() const { + return command_case() == kCancelQText; +} +inline void Command::set_has_cancelqtext() { + _impl_._oneof_case_[0] = kCancelQText; +} +inline void Command::clear_cancelqtext() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kCancelQText) { + if (GetArena() == nullptr) { + delete _impl_.command_.cancelqtext_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.cancelqtext_ != nullptr) { + _impl_.command_.cancelqtext_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::CancelQText* Command::release_cancelqtext() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.cancelQText) + if (command_case() == kCancelQText) { + clear_has_command(); + auto* temp = _impl_.command_.cancelqtext_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.cancelqtext_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::CancelQText& Command::_internal_cancelqtext() const { + return command_case() == kCancelQText ? *_impl_.command_.cancelqtext_ : reinterpret_cast<::dapi::commands::CancelQText&>(::dapi::commands::_CancelQText_default_instance_); +} +inline const ::dapi::commands::CancelQText& Command::cancelqtext() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.cancelQText) + return _internal_cancelqtext(); +} +inline ::dapi::commands::CancelQText* Command::unsafe_arena_release_cancelqtext() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.cancelQText) + if (command_case() == kCancelQText) { + clear_has_command(); + auto* temp = _impl_.command_.cancelqtext_; + _impl_.command_.cancelqtext_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_cancelqtext(::dapi::commands::CancelQText* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_cancelqtext(); + _impl_.command_.cancelqtext_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.cancelQText) +} +inline ::dapi::commands::CancelQText* Command::_internal_mutable_cancelqtext() { + if (command_case() != kCancelQText) { + clear_command(); + set_has_cancelqtext(); + _impl_.command_.cancelqtext_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CancelQText>(GetArena()); + } + return _impl_.command_.cancelqtext_; +} +inline ::dapi::commands::CancelQText* Command::mutable_cancelqtext() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::CancelQText* _msg = _internal_mutable_cancelqtext(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.cancelQText) + return _msg; +} + +// .dapi.commands.SetFPS setFPS = 25; +inline bool Command::has_setfps() const { + return command_case() == kSetFPS; +} +inline bool Command::_internal_has_setfps() const { + return command_case() == kSetFPS; +} +inline void Command::set_has_setfps() { + _impl_._oneof_case_[0] = kSetFPS; +} +inline void Command::clear_setfps() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSetFPS) { + if (GetArena() == nullptr) { + delete _impl_.command_.setfps_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.setfps_ != nullptr) { + _impl_.command_.setfps_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SetFPS* Command::release_setfps() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.setFPS) + if (command_case() == kSetFPS) { + clear_has_command(); + auto* temp = _impl_.command_.setfps_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.setfps_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SetFPS& Command::_internal_setfps() const { + return command_case() == kSetFPS ? *_impl_.command_.setfps_ : reinterpret_cast<::dapi::commands::SetFPS&>(::dapi::commands::_SetFPS_default_instance_); +} +inline const ::dapi::commands::SetFPS& Command::setfps() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.setFPS) + return _internal_setfps(); +} +inline ::dapi::commands::SetFPS* Command::unsafe_arena_release_setfps() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.setFPS) + if (command_case() == kSetFPS) { + clear_has_command(); + auto* temp = _impl_.command_.setfps_; + _impl_.command_.setfps_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_setfps(::dapi::commands::SetFPS* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_setfps(); + _impl_.command_.setfps_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.setFPS) +} +inline ::dapi::commands::SetFPS* Command::_internal_mutable_setfps() { + if (command_case() != kSetFPS) { + clear_command(); + set_has_setfps(); + _impl_.command_.setfps_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SetFPS>(GetArena()); + } + return _impl_.command_.setfps_; +} +inline ::dapi::commands::SetFPS* Command::mutable_setfps() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SetFPS* _msg = _internal_mutable_setfps(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.setFPS) + return _msg; +} + +// .dapi.commands.DisarmTrap disarmTrap = 26; +inline bool Command::has_disarmtrap() const { + return command_case() == kDisarmTrap; +} +inline bool Command::_internal_has_disarmtrap() const { + return command_case() == kDisarmTrap; +} +inline void Command::set_has_disarmtrap() { + _impl_._oneof_case_[0] = kDisarmTrap; +} +inline void Command::clear_disarmtrap() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kDisarmTrap) { + if (GetArena() == nullptr) { + delete _impl_.command_.disarmtrap_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.disarmtrap_ != nullptr) { + _impl_.command_.disarmtrap_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::DisarmTrap* Command::release_disarmtrap() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.disarmTrap) + if (command_case() == kDisarmTrap) { + clear_has_command(); + auto* temp = _impl_.command_.disarmtrap_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.disarmtrap_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::DisarmTrap& Command::_internal_disarmtrap() const { + return command_case() == kDisarmTrap ? *_impl_.command_.disarmtrap_ : reinterpret_cast<::dapi::commands::DisarmTrap&>(::dapi::commands::_DisarmTrap_default_instance_); +} +inline const ::dapi::commands::DisarmTrap& Command::disarmtrap() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.disarmTrap) + return _internal_disarmtrap(); +} +inline ::dapi::commands::DisarmTrap* Command::unsafe_arena_release_disarmtrap() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.disarmTrap) + if (command_case() == kDisarmTrap) { + clear_has_command(); + auto* temp = _impl_.command_.disarmtrap_; + _impl_.command_.disarmtrap_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_disarmtrap(); + _impl_.command_.disarmtrap_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.disarmTrap) +} +inline ::dapi::commands::DisarmTrap* Command::_internal_mutable_disarmtrap() { + if (command_case() != kDisarmTrap) { + clear_command(); + set_has_disarmtrap(); + _impl_.command_.disarmtrap_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::DisarmTrap>(GetArena()); + } + return _impl_.command_.disarmtrap_; +} +inline ::dapi::commands::DisarmTrap* Command::mutable_disarmtrap() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::DisarmTrap* _msg = _internal_mutable_disarmtrap(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.disarmTrap) + return _msg; +} + +// .dapi.commands.SkillRepair skillRepair = 27; +inline bool Command::has_skillrepair() const { + return command_case() == kSkillRepair; +} +inline bool Command::_internal_has_skillrepair() const { + return command_case() == kSkillRepair; +} +inline void Command::set_has_skillrepair() { + _impl_._oneof_case_[0] = kSkillRepair; +} +inline void Command::clear_skillrepair() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSkillRepair) { + if (GetArena() == nullptr) { + delete _impl_.command_.skillrepair_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.skillrepair_ != nullptr) { + _impl_.command_.skillrepair_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SkillRepair* Command::release_skillrepair() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.skillRepair) + if (command_case() == kSkillRepair) { + clear_has_command(); + auto* temp = _impl_.command_.skillrepair_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.skillrepair_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SkillRepair& Command::_internal_skillrepair() const { + return command_case() == kSkillRepair ? *_impl_.command_.skillrepair_ : reinterpret_cast<::dapi::commands::SkillRepair&>(::dapi::commands::_SkillRepair_default_instance_); +} +inline const ::dapi::commands::SkillRepair& Command::skillrepair() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.skillRepair) + return _internal_skillrepair(); +} +inline ::dapi::commands::SkillRepair* Command::unsafe_arena_release_skillrepair() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.skillRepair) + if (command_case() == kSkillRepair) { + clear_has_command(); + auto* temp = _impl_.command_.skillrepair_; + _impl_.command_.skillrepair_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_skillrepair(::dapi::commands::SkillRepair* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_skillrepair(); + _impl_.command_.skillrepair_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.skillRepair) +} +inline ::dapi::commands::SkillRepair* Command::_internal_mutable_skillrepair() { + if (command_case() != kSkillRepair) { + clear_command(); + set_has_skillrepair(); + _impl_.command_.skillrepair_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SkillRepair>(GetArena()); + } + return _impl_.command_.skillrepair_; +} +inline ::dapi::commands::SkillRepair* Command::mutable_skillrepair() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SkillRepair* _msg = _internal_mutable_skillrepair(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.skillRepair) + return _msg; +} + +// .dapi.commands.SkillRecharge skillRecharge = 28; +inline bool Command::has_skillrecharge() const { + return command_case() == kSkillRecharge; +} +inline bool Command::_internal_has_skillrecharge() const { + return command_case() == kSkillRecharge; +} +inline void Command::set_has_skillrecharge() { + _impl_._oneof_case_[0] = kSkillRecharge; +} +inline void Command::clear_skillrecharge() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSkillRecharge) { + if (GetArena() == nullptr) { + delete _impl_.command_.skillrecharge_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.skillrecharge_ != nullptr) { + _impl_.command_.skillrecharge_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SkillRecharge* Command::release_skillrecharge() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.skillRecharge) + if (command_case() == kSkillRecharge) { + clear_has_command(); + auto* temp = _impl_.command_.skillrecharge_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.skillrecharge_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SkillRecharge& Command::_internal_skillrecharge() const { + return command_case() == kSkillRecharge ? *_impl_.command_.skillrecharge_ : reinterpret_cast<::dapi::commands::SkillRecharge&>(::dapi::commands::_SkillRecharge_default_instance_); +} +inline const ::dapi::commands::SkillRecharge& Command::skillrecharge() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.skillRecharge) + return _internal_skillrecharge(); +} +inline ::dapi::commands::SkillRecharge* Command::unsafe_arena_release_skillrecharge() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.skillRecharge) + if (command_case() == kSkillRecharge) { + clear_has_command(); + auto* temp = _impl_.command_.skillrecharge_; + _impl_.command_.skillrecharge_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_skillrecharge(); + _impl_.command_.skillrecharge_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.skillRecharge) +} +inline ::dapi::commands::SkillRecharge* Command::_internal_mutable_skillrecharge() { + if (command_case() != kSkillRecharge) { + clear_command(); + set_has_skillrecharge(); + _impl_.command_.skillrecharge_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SkillRecharge>(GetArena()); + } + return _impl_.command_.skillrecharge_; +} +inline ::dapi::commands::SkillRecharge* Command::mutable_skillrecharge() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SkillRecharge* _msg = _internal_mutable_skillrecharge(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.skillRecharge) + return _msg; +} + +// .dapi.commands.ToggleMenu toggleMenu = 29; +inline bool Command::has_togglemenu() const { + return command_case() == kToggleMenu; +} +inline bool Command::_internal_has_togglemenu() const { + return command_case() == kToggleMenu; +} +inline void Command::set_has_togglemenu() { + _impl_._oneof_case_[0] = kToggleMenu; +} +inline void Command::clear_togglemenu() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kToggleMenu) { + if (GetArena() == nullptr) { + delete _impl_.command_.togglemenu_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.togglemenu_ != nullptr) { + _impl_.command_.togglemenu_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::ToggleMenu* Command::release_togglemenu() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleMenu) + if (command_case() == kToggleMenu) { + clear_has_command(); + auto* temp = _impl_.command_.togglemenu_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.togglemenu_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::ToggleMenu& Command::_internal_togglemenu() const { + return command_case() == kToggleMenu ? *_impl_.command_.togglemenu_ : reinterpret_cast<::dapi::commands::ToggleMenu&>(::dapi::commands::_ToggleMenu_default_instance_); +} +inline const ::dapi::commands::ToggleMenu& Command::togglemenu() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleMenu) + return _internal_togglemenu(); +} +inline ::dapi::commands::ToggleMenu* Command::unsafe_arena_release_togglemenu() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleMenu) + if (command_case() == kToggleMenu) { + clear_has_command(); + auto* temp = _impl_.command_.togglemenu_; + _impl_.command_.togglemenu_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_togglemenu(::dapi::commands::ToggleMenu* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_togglemenu(); + _impl_.command_.togglemenu_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleMenu) +} +inline ::dapi::commands::ToggleMenu* Command::_internal_mutable_togglemenu() { + if (command_case() != kToggleMenu) { + clear_command(); + set_has_togglemenu(); + _impl_.command_.togglemenu_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleMenu>(GetArena()); + } + return _impl_.command_.togglemenu_; +} +inline ::dapi::commands::ToggleMenu* Command::mutable_togglemenu() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::ToggleMenu* _msg = _internal_mutable_togglemenu(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleMenu) + return _msg; +} + +// .dapi.commands.SaveGame saveGame = 30; +inline bool Command::has_savegame() const { + return command_case() == kSaveGame; +} +inline bool Command::_internal_has_savegame() const { + return command_case() == kSaveGame; +} +inline void Command::set_has_savegame() { + _impl_._oneof_case_[0] = kSaveGame; +} +inline void Command::clear_savegame() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kSaveGame) { + if (GetArena() == nullptr) { + delete _impl_.command_.savegame_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.savegame_ != nullptr) { + _impl_.command_.savegame_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::SaveGame* Command::release_savegame() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.saveGame) + if (command_case() == kSaveGame) { + clear_has_command(); + auto* temp = _impl_.command_.savegame_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.savegame_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::SaveGame& Command::_internal_savegame() const { + return command_case() == kSaveGame ? *_impl_.command_.savegame_ : reinterpret_cast<::dapi::commands::SaveGame&>(::dapi::commands::_SaveGame_default_instance_); +} +inline const ::dapi::commands::SaveGame& Command::savegame() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.saveGame) + return _internal_savegame(); +} +inline ::dapi::commands::SaveGame* Command::unsafe_arena_release_savegame() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.saveGame) + if (command_case() == kSaveGame) { + clear_has_command(); + auto* temp = _impl_.command_.savegame_; + _impl_.command_.savegame_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_savegame(::dapi::commands::SaveGame* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_savegame(); + _impl_.command_.savegame_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.saveGame) +} +inline ::dapi::commands::SaveGame* Command::_internal_mutable_savegame() { + if (command_case() != kSaveGame) { + clear_command(); + set_has_savegame(); + _impl_.command_.savegame_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SaveGame>(GetArena()); + } + return _impl_.command_.savegame_; +} +inline ::dapi::commands::SaveGame* Command::mutable_savegame() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::SaveGame* _msg = _internal_mutable_savegame(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.saveGame) + return _msg; +} + +// .dapi.commands.Quit quit = 31; +inline bool Command::has_quit() const { + return command_case() == kQuit; +} +inline bool Command::_internal_has_quit() const { + return command_case() == kQuit; +} +inline void Command::set_has_quit() { + _impl_._oneof_case_[0] = kQuit; +} +inline void Command::clear_quit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kQuit) { + if (GetArena() == nullptr) { + delete _impl_.command_.quit_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.quit_ != nullptr) { + _impl_.command_.quit_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::Quit* Command::release_quit() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.quit) + if (command_case() == kQuit) { + clear_has_command(); + auto* temp = _impl_.command_.quit_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.quit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::Quit& Command::_internal_quit() const { + return command_case() == kQuit ? *_impl_.command_.quit_ : reinterpret_cast<::dapi::commands::Quit&>(::dapi::commands::_Quit_default_instance_); +} +inline const ::dapi::commands::Quit& Command::quit() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.quit) + return _internal_quit(); +} +inline ::dapi::commands::Quit* Command::unsafe_arena_release_quit() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.quit) + if (command_case() == kQuit) { + clear_has_command(); + auto* temp = _impl_.command_.quit_; + _impl_.command_.quit_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_quit(::dapi::commands::Quit* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_quit(); + _impl_.command_.quit_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.quit) +} +inline ::dapi::commands::Quit* Command::_internal_mutable_quit() { + if (command_case() != kQuit) { + clear_command(); + set_has_quit(); + _impl_.command_.quit_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Quit>(GetArena()); + } + return _impl_.command_.quit_; +} +inline ::dapi::commands::Quit* Command::mutable_quit() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::Quit* _msg = _internal_mutable_quit(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.quit) + return _msg; +} + +// .dapi.commands.ClearCursor clearCursor = 32; +inline bool Command::has_clearcursor() const { + return command_case() == kClearCursor; +} +inline bool Command::_internal_has_clearcursor() const { + return command_case() == kClearCursor; +} +inline void Command::set_has_clearcursor() { + _impl_._oneof_case_[0] = kClearCursor; +} +inline void Command::clear_clearcursor() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kClearCursor) { + if (GetArena() == nullptr) { + delete _impl_.command_.clearcursor_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.clearcursor_ != nullptr) { + _impl_.command_.clearcursor_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::ClearCursor* Command::release_clearcursor() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.clearCursor) + if (command_case() == kClearCursor) { + clear_has_command(); + auto* temp = _impl_.command_.clearcursor_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.clearcursor_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::ClearCursor& Command::_internal_clearcursor() const { + return command_case() == kClearCursor ? *_impl_.command_.clearcursor_ : reinterpret_cast<::dapi::commands::ClearCursor&>(::dapi::commands::_ClearCursor_default_instance_); +} +inline const ::dapi::commands::ClearCursor& Command::clearcursor() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.clearCursor) + return _internal_clearcursor(); +} +inline ::dapi::commands::ClearCursor* Command::unsafe_arena_release_clearcursor() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.clearCursor) + if (command_case() == kClearCursor) { + clear_has_command(); + auto* temp = _impl_.command_.clearcursor_; + _impl_.command_.clearcursor_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_clearcursor(::dapi::commands::ClearCursor* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_clearcursor(); + _impl_.command_.clearcursor_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.clearCursor) +} +inline ::dapi::commands::ClearCursor* Command::_internal_mutable_clearcursor() { + if (command_case() != kClearCursor) { + clear_command(); + set_has_clearcursor(); + _impl_.command_.clearcursor_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ClearCursor>(GetArena()); + } + return _impl_.command_.clearcursor_; +} +inline ::dapi::commands::ClearCursor* Command::mutable_clearcursor() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::ClearCursor* _msg = _internal_mutable_clearcursor(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.clearCursor) + return _msg; +} + +// .dapi.commands.IdentifyItem identifyItem = 33; +inline bool Command::has_identifyitem() const { + return command_case() == kIdentifyItem; +} +inline bool Command::_internal_has_identifyitem() const { + return command_case() == kIdentifyItem; +} +inline void Command::set_has_identifyitem() { + _impl_._oneof_case_[0] = kIdentifyItem; +} +inline void Command::clear_identifyitem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (command_case() == kIdentifyItem) { + if (GetArena() == nullptr) { + delete _impl_.command_.identifyitem_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.command_.identifyitem_ != nullptr) { + _impl_.command_.identifyitem_->Clear(); + } + } + clear_has_command(); + } +} +inline ::dapi::commands::IdentifyItem* Command::release_identifyitem() { + // @@protoc_insertion_point(field_release:dapi.commands.Command.identifyItem) + if (command_case() == kIdentifyItem) { + clear_has_command(); + auto* temp = _impl_.command_.identifyitem_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.command_.identifyitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::IdentifyItem& Command::_internal_identifyitem() const { + return command_case() == kIdentifyItem ? *_impl_.command_.identifyitem_ : reinterpret_cast<::dapi::commands::IdentifyItem&>(::dapi::commands::_IdentifyItem_default_instance_); +} +inline const ::dapi::commands::IdentifyItem& Command::identifyitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.commands.Command.identifyItem) + return _internal_identifyitem(); +} +inline ::dapi::commands::IdentifyItem* Command::unsafe_arena_release_identifyitem() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.identifyItem) + if (command_case() == kIdentifyItem) { + clear_has_command(); + auto* temp = _impl_.command_.identifyitem_; + _impl_.command_.identifyitem_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Command::unsafe_arena_set_allocated_identifyitem(::dapi::commands::IdentifyItem* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_command(); + if (value) { + set_has_identifyitem(); + _impl_.command_.identifyitem_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.identifyItem) +} +inline ::dapi::commands::IdentifyItem* Command::_internal_mutable_identifyitem() { + if (command_case() != kIdentifyItem) { + clear_command(); + set_has_identifyitem(); + _impl_.command_.identifyitem_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IdentifyItem>(GetArena()); + } + return _impl_.command_.identifyitem_; +} +inline ::dapi::commands::IdentifyItem* Command::mutable_identifyitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::IdentifyItem* _msg = _internal_mutable_identifyitem(); + // @@protoc_insertion_point(field_mutable:dapi.commands.Command.identifyItem) + return _msg; +} + +inline bool Command::has_command() const { + return command_case() != COMMAND_NOT_SET; +} +inline void Command::clear_has_command() { + _impl_._oneof_case_[0] = COMMAND_NOT_SET; +} +inline Command::CommandCase Command::command_case() const { + return Command::CommandCase(_impl_._oneof_case_[0]); +} +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace commands +} // namespace dapi + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // command_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/data.pb.cc b/Source/dapi/Backend/Messages/generated/data.pb.cc new file mode 100644 index 000000000..515b33f1d --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/data.pb.cc @@ -0,0 +1,5512 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: data.proto +// Protobuf C++ Version: 5.29.3 + +#include "data.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace dapi { +namespace data { + +inline constexpr TriggerData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : lvl_{0u}, + x_{0}, + y_{0}, + type_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR TriggerData::TriggerData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct TriggerDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR TriggerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TriggerDataDefaultTypeInternal() {} + union { + TriggerData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TriggerDataDefaultTypeInternal _TriggerData_default_instance_; + +inline constexpr TownerData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _tname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + id_{0u}, + _ttype_{0u}, + _tx_{0}, + _ty_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR TownerData::TownerData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct TownerDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR TownerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TownerDataDefaultTypeInternal() {} + union { + TownerData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TownerDataDefaultTypeInternal _TownerData_default_instance_; + +inline constexpr TileData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : type_{0}, + x_{0}, + solid_{false}, + stopmissile_{false}, + y_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR TileData::TileData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct TileDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR TileDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~TileDataDefaultTypeInternal() {} + union { + TileData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TileDataDefaultTypeInternal _TileData_default_instance_; + +inline constexpr QuestData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : id_{0u}, + state_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR QuestData::QuestData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct QuestDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR QuestDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~QuestDataDefaultTypeInternal() {} + union { + QuestData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QuestDataDefaultTypeInternal _QuestData_default_instance_; + +inline constexpr PortalData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : x_{0u}, + y_{0u}, + player_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR PortalData::PortalData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct PortalDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR PortalDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PortalDataDefaultTypeInternal() {} + union { + PortalData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PortalDataDefaultTypeInternal _PortalData_default_instance_; + +inline constexpr PlayerData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _pspllvl_{}, + __pspllvl_cached_byte_size_{0}, + invbody_{}, + _invbody_cached_byte_size_{0}, + invlist_{}, + _invlist_cached_byte_size_{0}, + invgrid_{}, + _invgrid_cached_byte_size_{0}, + spdlist_{}, + _spdlist_cached_byte_size_{0}, + _pname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _pmode_{0}, + pnum_{0}, + plrlevel_{0}, + _px_{0}, + _py_{0}, + _pfutx_{0}, + _pfuty_{0}, + _pdir_{0}, + _prspell_{0}, + _prspltype_{0u}, + _pmemspells_{::uint64_t{0u}}, + _pablspells_{::uint64_t{0u}}, + _pscrlspells_{::uint64_t{0u}}, + _pclass_{0u}, + _pstrength_{0u}, + _pbasestr_{0u}, + _pmagic_{0u}, + _pbasemag_{0u}, + _pdexterity_{0u}, + _pbasedex_{0u}, + _pvitality_{0u}, + _pbasevit_{0u}, + _pstatpts_{0u}, + _pdamagemod_{0u}, + _phitpoints_{0u}, + _pmaxhp_{0u}, + _pmana_{0}, + _pmaxmana_{0u}, + _plevel_{0u}, + _pexperience_{0u}, + _parmorclass_{0u}, + _pmagresist_{0u}, + _pfireresist_{0u}, + _plightresist_{0u}, + _pgold_{0u}, + holditem_{0}, + _piac_{0u}, + _pimindam_{0u}, + _pimaxdam_{0u}, + _pibonusdam_{0u}, + _pibonustohit_{0u}, + _pibonusac_{0u}, + _pibonusdammod_{0u}, + pmanashield_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR PlayerData::PlayerData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct PlayerDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR PlayerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~PlayerDataDefaultTypeInternal() {} + union { + PlayerData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PlayerDataDefaultTypeInternal _PlayerData_default_instance_; + +inline constexpr ObjectData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : x_{0u}, + y_{0u}, + type_{0}, + shrinetype_{0}, + doorstate_{0}, + solid_{false}, + selectable_{false}, + trapped_{false}, + index_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ObjectData::ObjectData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ObjectDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ObjectDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ObjectDataDefaultTypeInternal() {} + union { + ObjectData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObjectDataDefaultTypeInternal _ObjectData_default_instance_; + +inline constexpr MonsterData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : name_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + index_{0u}, + x_{0}, + y_{0}, + futx_{0}, + futy_{0}, + type_{0}, + kills_{0}, + mode_{0}, + unique_{false}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR MonsterData::MonsterData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct MonsterDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR MonsterDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~MonsterDataDefaultTypeInternal() {} + union { + MonsterData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MonsterDataDefaultTypeInternal _MonsterData_default_instance_; + +inline constexpr MissileData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : type_{0}, + x_{0u}, + y_{0u}, + xvel_{0}, + yvel_{0}, + sx_{0}, + sy_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR MissileData::MissileData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct MissileDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR MissileDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~MissileDataDefaultTypeInternal() {} + union { + MissileData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MissileDataDefaultTypeInternal _MissileData_default_instance_; + +inline constexpr ItemData::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _iname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + _iiname_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + id_{0u}, + _itype_{0}, + _ix_{0}, + _iy_{0}, + _imagical_{0u}, + _iclass_{0u}, + _icurs_{0}, + _ivalue_{0}, + _imindam_{0}, + _imaxdam_{0}, + _iac_{0}, + _iflags_{0}, + _imiscid_{0}, + _ispell_{0}, + _icharges_{0}, + _imaxcharges_{0}, + _idurability_{0}, + _imaxdur_{0}, + _ipldam_{0}, + _ipltohit_{0}, + _iplac_{0}, + _iplstr_{0}, + _iplmag_{0}, + _iidentified_{false}, + _istatflag_{false}, + _ipldex_{0}, + _iplvit_{0}, + _iplfr_{0}, + _ipllr_{0}, + _iplmr_{0}, + _iplmana_{0}, + _iplhp_{0}, + _ipldammod_{0}, + _iplgethit_{0}, + _ipllight_{0}, + _ispllvladd_{0}, + _ifmindam_{0}, + _ifmaxdam_{0}, + _ilmindam_{0}, + _ilmaxdam_{0}, + _iprepower_{0}, + _isufpower_{0}, + _iminstr_{0}, + _iminmag_{0}, + _imindex_{0}, + ididx_{0}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ItemData::ItemData(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ItemDataDefaultTypeInternal { + PROTOBUF_CONSTEXPR ItemDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ItemDataDefaultTypeInternal() {} + union { + ItemData _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ItemDataDefaultTypeInternal _ItemData_default_instance_; +} // namespace data +} // namespace dapi +namespace dapi { +namespace data { +// =================================================================== + +class QuestData::_Internal { + public: +}; + +QuestData::QuestData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.QuestData) +} +QuestData::QuestData( + ::google::protobuf::Arena* arena, const QuestData& from) + : QuestData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE QuestData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void QuestData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, id_), + 0, + offsetof(Impl_, state_) - + offsetof(Impl_, id_) + + sizeof(Impl_::state_)); +} +QuestData::~QuestData() { + // @@protoc_insertion_point(destructor:dapi.data.QuestData) + SharedDtor(*this); +} +inline void QuestData::SharedDtor(MessageLite& self) { + QuestData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* QuestData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) QuestData(arena); +} +constexpr auto QuestData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(QuestData), + alignof(QuestData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<20> QuestData::_class_data_ = { + { + &_QuestData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &QuestData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &QuestData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &QuestData::ByteSizeLong, + &QuestData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(QuestData, _impl_._cached_size_), + true, + }, + "dapi.data.QuestData", +}; +const ::google::protobuf::internal::ClassData* QuestData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<1, 2, 0, 0, 2> QuestData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 2, 8, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967292, // skipmap + offsetof(decltype(_table_), field_entries), + 2, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::QuestData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 state = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_)}}, + // uint32 id = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 id = 1; + {PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 state = 2; + {PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void QuestData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.QuestData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.state_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.state_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* QuestData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const QuestData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* QuestData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const QuestData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.QuestData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 id = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + // uint32 state = 2; + if (this_._internal_state() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_state(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.QuestData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t QuestData::ByteSizeLong(const MessageLite& base) { + const QuestData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t QuestData::ByteSizeLong() const { + const QuestData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.QuestData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 id = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + // uint32 state = 2; + if (this_._internal_state() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_state()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void QuestData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.QuestData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + if (from._internal_state() != 0) { + _this->_impl_.state_ = from._impl_.state_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void QuestData::CopyFrom(const QuestData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.QuestData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void QuestData::InternalSwap(QuestData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_) + + sizeof(QuestData::_impl_.state_) + - PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +// =================================================================== + +class PortalData::_Internal { + public: +}; + +PortalData::PortalData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.PortalData) +} +PortalData::PortalData( + ::google::protobuf::Arena* arena, const PortalData& from) + : PortalData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE PortalData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void PortalData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, x_), + 0, + offsetof(Impl_, player_) - + offsetof(Impl_, x_) + + sizeof(Impl_::player_)); +} +PortalData::~PortalData() { + // @@protoc_insertion_point(destructor:dapi.data.PortalData) + SharedDtor(*this); +} +inline void PortalData::SharedDtor(MessageLite& self) { + PortalData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* PortalData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PortalData(arena); +} +constexpr auto PortalData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PortalData), + alignof(PortalData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> PortalData::_class_data_ = { + { + &_PortalData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PortalData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PortalData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &PortalData::ByteSizeLong, + &PortalData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PortalData, _impl_._cached_size_), + true, + }, + "dapi.data.PortalData", +}; +const ::google::protobuf::internal::ClassData* PortalData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 3, 0, 0, 2> PortalData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 3, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967288, // skipmap + offsetof(decltype(_table_), field_entries), + 3, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::PortalData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 x = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_)}}, + // uint32 y = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.y_)}}, + // uint32 player = 3; + {::_pbi::TcParser::FastV32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 x = 1; + {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 y = 2; + {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 player = 3; + {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void PortalData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.PortalData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.player_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.player_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* PortalData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const PortalData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* PortalData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const PortalData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.PortalData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 x = 1; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_x(), target); + } + + // uint32 y = 2; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_y(), target); + } + + // uint32 player = 3; + if (this_._internal_player() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_player(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.PortalData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t PortalData::ByteSizeLong(const MessageLite& base) { + const PortalData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t PortalData::ByteSizeLong() const { + const PortalData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.PortalData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 x = 1; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_x()); + } + // uint32 y = 2; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_y()); + } + // uint32 player = 3; + if (this_._internal_player() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_player()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void PortalData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.PortalData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + if (from._internal_player() != 0) { + _this->_impl_.player_ = from._impl_.player_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PortalData::CopyFrom(const PortalData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.PortalData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void PortalData::InternalSwap(PortalData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_) + + sizeof(PortalData::_impl_.player_) + - PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +// =================================================================== + +class MissileData::_Internal { + public: +}; + +MissileData::MissileData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.MissileData) +} +MissileData::MissileData( + ::google::protobuf::Arena* arena, const MissileData& from) + : MissileData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE MissileData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void MissileData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, type_), + 0, + offsetof(Impl_, sy_) - + offsetof(Impl_, type_) + + sizeof(Impl_::sy_)); +} +MissileData::~MissileData() { + // @@protoc_insertion_point(destructor:dapi.data.MissileData) + SharedDtor(*this); +} +inline void MissileData::SharedDtor(MessageLite& self) { + MissileData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* MissileData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) MissileData(arena); +} +constexpr auto MissileData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(MissileData), + alignof(MissileData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> MissileData::_class_data_ = { + { + &_MissileData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &MissileData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &MissileData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &MissileData::ByteSizeLong, + &MissileData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(MissileData, _impl_._cached_size_), + true, + }, + "dapi.data.MissileData", +}; +const ::google::protobuf::internal::ClassData* MissileData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 7, 0, 0, 2> MissileData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 7, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967168, // skipmap + offsetof(decltype(_table_), field_entries), + 7, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::MissileData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // sint32 type = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_)}}, + // uint32 x = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.x_)}}, + // uint32 y = 3; + {::_pbi::TcParser::FastV32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.y_)}}, + // sint32 xvel = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.xvel_)}}, + // sint32 yvel = 5; + {::_pbi::TcParser::FastZ32S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.yvel_)}}, + // sint32 sx = 6; + {::_pbi::TcParser::FastZ32S1, + {48, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sx_)}}, + // sint32 sy = 7; + {::_pbi::TcParser::FastZ32S1, + {56, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 type = 1; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // uint32 x = 2; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 y = 3; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 xvel = 4; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.xvel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 yvel = 5; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.yvel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 sx = 6; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 sy = 7; + {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void MissileData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.MissileData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.type_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.sy_) - + reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.sy_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* MissileData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const MissileData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* MissileData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const MissileData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.MissileData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 type = 1; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_type(), target); + } + + // uint32 x = 2; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_x(), target); + } + + // uint32 y = 3; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 3, this_._internal_y(), target); + } + + // sint32 xvel = 4; + if (this_._internal_xvel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal_xvel(), target); + } + + // sint32 yvel = 5; + if (this_._internal_yvel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 5, this_._internal_yvel(), target); + } + + // sint32 sx = 6; + if (this_._internal_sx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 6, this_._internal_sx(), target); + } + + // sint32 sy = 7; + if (this_._internal_sy() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 7, this_._internal_sy(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.MissileData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t MissileData::ByteSizeLong(const MessageLite& base) { + const MissileData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t MissileData::ByteSizeLong() const { + const MissileData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.MissileData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // sint32 type = 1; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_type()); + } + // uint32 x = 2; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_x()); + } + // uint32 y = 3; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_y()); + } + // sint32 xvel = 4; + if (this_._internal_xvel() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_xvel()); + } + // sint32 yvel = 5; + if (this_._internal_yvel() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_yvel()); + } + // sint32 sx = 6; + if (this_._internal_sx() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_sx()); + } + // sint32 sy = 7; + if (this_._internal_sy() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_sy()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void MissileData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.MissileData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + if (from._internal_xvel() != 0) { + _this->_impl_.xvel_ = from._impl_.xvel_; + } + if (from._internal_yvel() != 0) { + _this->_impl_.yvel_ = from._impl_.yvel_; + } + if (from._internal_sx() != 0) { + _this->_impl_.sx_ = from._impl_.sx_; + } + if (from._internal_sy() != 0) { + _this->_impl_.sy_ = from._impl_.sy_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void MissileData::CopyFrom(const MissileData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.MissileData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void MissileData::InternalSwap(MissileData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_) + + sizeof(MissileData::_impl_.sy_) + - PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_)>( + reinterpret_cast(&_impl_.type_), + reinterpret_cast(&other->_impl_.type_)); +} + +// =================================================================== + +class ObjectData::_Internal { + public: +}; + +ObjectData::ObjectData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.ObjectData) +} +ObjectData::ObjectData( + ::google::protobuf::Arena* arena, const ObjectData& from) + : ObjectData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ObjectData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ObjectData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, x_), + 0, + offsetof(Impl_, index_) - + offsetof(Impl_, x_) + + sizeof(Impl_::index_)); +} +ObjectData::~ObjectData() { + // @@protoc_insertion_point(destructor:dapi.data.ObjectData) + SharedDtor(*this); +} +inline void ObjectData::SharedDtor(MessageLite& self) { + ObjectData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ObjectData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ObjectData(arena); +} +constexpr auto ObjectData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ObjectData), + alignof(ObjectData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> ObjectData::_class_data_ = { + { + &_ObjectData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ObjectData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ObjectData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ObjectData::ByteSizeLong, + &ObjectData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ObjectData, _impl_._cached_size_), + true, + }, + "dapi.data.ObjectData", +}; +const ::google::protobuf::internal::ClassData* ObjectData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 9, 0, 0, 2> ObjectData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 9, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966784, // skipmap + offsetof(decltype(_table_), field_entries), + 9, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::ObjectData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 x = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_)}}, + // uint32 y = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.y_)}}, + // sint32 type = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.type_)}}, + // sint32 shrineType = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.shrinetype_)}}, + // bool solid = 5; + {::_pbi::TcParser::FastV8S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.solid_)}}, + // sint32 doorState = 6; + {::_pbi::TcParser::FastZ32S1, + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.doorstate_)}}, + // bool selectable = 7; + {::_pbi::TcParser::FastV8S1, + {56, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.selectable_)}}, + // uint32 index = 8; + {::_pbi::TcParser::FastV32S1, + {64, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_)}}, + // bool trapped = 9; + {::_pbi::TcParser::FastV8S1, + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.trapped_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 x = 1; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 y = 2; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 type = 3; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 shrineType = 4; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.shrinetype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool solid = 5; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.solid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // sint32 doorState = 6; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.doorstate_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool selectable = 7; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.selectable_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 index = 8; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // bool trapped = 9; + {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.trapped_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ObjectData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.ObjectData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.x_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.index_) - + reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.index_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ObjectData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ObjectData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ObjectData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ObjectData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.ObjectData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 x = 1; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_x(), target); + } + + // uint32 y = 2; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal_y(), target); + } + + // sint32 type = 3; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_type(), target); + } + + // sint32 shrineType = 4; + if (this_._internal_shrinetype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal_shrinetype(), target); + } + + // bool solid = 5; + if (this_._internal_solid() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_solid(), target); + } + + // sint32 doorState = 6; + if (this_._internal_doorstate() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 6, this_._internal_doorstate(), target); + } + + // bool selectable = 7; + if (this_._internal_selectable() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 7, this_._internal_selectable(), target); + } + + // uint32 index = 8; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 8, this_._internal_index(), target); + } + + // bool trapped = 9; + if (this_._internal_trapped() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 9, this_._internal_trapped(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.ObjectData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ObjectData::ByteSizeLong(const MessageLite& base) { + const ObjectData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ObjectData::ByteSizeLong() const { + const ObjectData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.ObjectData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 x = 1; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_x()); + } + // uint32 y = 2; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_y()); + } + // sint32 type = 3; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_type()); + } + // sint32 shrineType = 4; + if (this_._internal_shrinetype() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_shrinetype()); + } + // sint32 doorState = 6; + if (this_._internal_doorstate() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_doorstate()); + } + // bool solid = 5; + if (this_._internal_solid() != 0) { + total_size += 2; + } + // bool selectable = 7; + if (this_._internal_selectable() != 0) { + total_size += 2; + } + // bool trapped = 9; + if (this_._internal_trapped() != 0) { + total_size += 2; + } + // uint32 index = 8; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ObjectData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.ObjectData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + if (from._internal_shrinetype() != 0) { + _this->_impl_.shrinetype_ = from._impl_.shrinetype_; + } + if (from._internal_doorstate() != 0) { + _this->_impl_.doorstate_ = from._impl_.doorstate_; + } + if (from._internal_solid() != 0) { + _this->_impl_.solid_ = from._impl_.solid_; + } + if (from._internal_selectable() != 0) { + _this->_impl_.selectable_ = from._impl_.selectable_; + } + if (from._internal_trapped() != 0) { + _this->_impl_.trapped_ = from._impl_.trapped_; + } + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ObjectData::CopyFrom(const ObjectData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.ObjectData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ObjectData::InternalSwap(ObjectData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_) + + sizeof(ObjectData::_impl_.index_) + - PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_)>( + reinterpret_cast(&_impl_.x_), + reinterpret_cast(&other->_impl_.x_)); +} + +// =================================================================== + +class MonsterData::_Internal { + public: +}; + +MonsterData::MonsterData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.MonsterData) +} +inline PROTOBUF_NDEBUG_INLINE MonsterData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::data::MonsterData& from_msg) + : name_(arena, from.name_), + _cached_size_{0} {} + +MonsterData::MonsterData( + ::google::protobuf::Arena* arena, + const MonsterData& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + MonsterData* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, index_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, index_), + offsetof(Impl_, unique_) - + offsetof(Impl_, index_) + + sizeof(Impl_::unique_)); + + // @@protoc_insertion_point(copy_constructor:dapi.data.MonsterData) +} +inline PROTOBUF_NDEBUG_INLINE MonsterData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : name_(arena), + _cached_size_{0} {} + +inline void MonsterData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, index_), + 0, + offsetof(Impl_, unique_) - + offsetof(Impl_, index_) + + sizeof(Impl_::unique_)); +} +MonsterData::~MonsterData() { + // @@protoc_insertion_point(destructor:dapi.data.MonsterData) + SharedDtor(*this); +} +inline void MonsterData::SharedDtor(MessageLite& self) { + MonsterData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.name_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* MonsterData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) MonsterData(arena); +} +constexpr auto MonsterData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(MonsterData), + alignof(MonsterData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> MonsterData::_class_data_ = { + { + &_MonsterData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &MonsterData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &MonsterData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &MonsterData::ByteSizeLong, + &MonsterData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(MonsterData, _impl_._cached_size_), + true, + }, + "dapi.data.MonsterData", +}; +const ::google::protobuf::internal::ClassData* MonsterData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<4, 10, 0, 42, 2> MonsterData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 10, 120, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294966272, // skipmap + offsetof(decltype(_table_), field_entries), + 10, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::MonsterData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 index = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_)}}, + // sint32 x = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.x_)}}, + // sint32 y = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.y_)}}, + // sint32 futx = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futx_)}}, + // sint32 futy = 5; + {::_pbi::TcParser::FastZ32S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futy_)}}, + // string name = 6; + {::_pbi::TcParser::FastUS1, + {50, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.name_)}}, + // sint32 type = 7; + {::_pbi::TcParser::FastZ32S1, + {56, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.type_)}}, + // sint32 kills = 8; + {::_pbi::TcParser::FastZ32S1, + {64, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.kills_)}}, + // sint32 mode = 9; + {::_pbi::TcParser::FastZ32S1, + {72, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.mode_)}}, + // bool unique = 10; + {::_pbi::TcParser::FastV8S1, + {80, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 index = 1; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 x = 2; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 y = 3; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 futx = 4; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 futy = 5; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // string name = 6; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.name_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // sint32 type = 7; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 kills = 8; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.kills_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 mode = 9; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.mode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool unique = 10; + {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\25\0\0\0\0\0\4\0\0\0\0\0\0\0\0\0" + "dapi.data.MonsterData" + "name" + }}, +}; + +PROTOBUF_NOINLINE void MonsterData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.MonsterData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.name_.ClearToEmpty(); + ::memset(&_impl_.index_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.unique_) - + reinterpret_cast(&_impl_.index_)) + sizeof(_impl_.unique_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* MonsterData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const MonsterData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* MonsterData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const MonsterData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.MonsterData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 index = 1; + if (this_._internal_index() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_index(), target); + } + + // sint32 x = 2; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_x(), target); + } + + // sint32 y = 3; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_y(), target); + } + + // sint32 futx = 4; + if (this_._internal_futx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal_futx(), target); + } + + // sint32 futy = 5; + if (this_._internal_futy() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 5, this_._internal_futy(), target); + } + + // string name = 6; + if (!this_._internal_name().empty()) { + const std::string& _s = this_._internal_name(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.MonsterData.name"); + target = stream->WriteStringMaybeAliased(6, _s, target); + } + + // sint32 type = 7; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 7, this_._internal_type(), target); + } + + // sint32 kills = 8; + if (this_._internal_kills() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 8, this_._internal_kills(), target); + } + + // sint32 mode = 9; + if (this_._internal_mode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 9, this_._internal_mode(), target); + } + + // bool unique = 10; + if (this_._internal_unique() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 10, this_._internal_unique(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.MonsterData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t MonsterData::ByteSizeLong(const MessageLite& base) { + const MonsterData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t MonsterData::ByteSizeLong() const { + const MonsterData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.MonsterData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string name = 6; + if (!this_._internal_name().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_name()); + } + // uint32 index = 1; + if (this_._internal_index() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_index()); + } + // sint32 x = 2; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_x()); + } + // sint32 y = 3; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_y()); + } + // sint32 futx = 4; + if (this_._internal_futx() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_futx()); + } + // sint32 futy = 5; + if (this_._internal_futy() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_futy()); + } + // sint32 type = 7; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_type()); + } + // sint32 kills = 8; + if (this_._internal_kills() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_kills()); + } + // sint32 mode = 9; + if (this_._internal_mode() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_mode()); + } + // bool unique = 10; + if (this_._internal_unique() != 0) { + total_size += 2; + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void MonsterData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.MonsterData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal_name().empty()) { + _this->_internal_set_name(from._internal_name()); + } + if (from._internal_index() != 0) { + _this->_impl_.index_ = from._impl_.index_; + } + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + if (from._internal_futx() != 0) { + _this->_impl_.futx_ = from._impl_.futx_; + } + if (from._internal_futy() != 0) { + _this->_impl_.futy_ = from._impl_.futy_; + } + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + if (from._internal_kills() != 0) { + _this->_impl_.kills_ = from._impl_.kills_; + } + if (from._internal_mode() != 0) { + _this->_impl_.mode_ = from._impl_.mode_; + } + if (from._internal_unique() != 0) { + _this->_impl_.unique_ = from._impl_.unique_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void MonsterData::CopyFrom(const MonsterData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.MonsterData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void MonsterData::InternalSwap(MonsterData* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_) + + sizeof(MonsterData::_impl_.unique_) + - PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_)>( + reinterpret_cast(&_impl_.index_), + reinterpret_cast(&other->_impl_.index_)); +} + +// =================================================================== + +class TriggerData::_Internal { + public: +}; + +TriggerData::TriggerData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.TriggerData) +} +TriggerData::TriggerData( + ::google::protobuf::Arena* arena, const TriggerData& from) + : TriggerData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE TriggerData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void TriggerData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, lvl_), + 0, + offsetof(Impl_, type_) - + offsetof(Impl_, lvl_) + + sizeof(Impl_::type_)); +} +TriggerData::~TriggerData() { + // @@protoc_insertion_point(destructor:dapi.data.TriggerData) + SharedDtor(*this); +} +inline void TriggerData::SharedDtor(MessageLite& self) { + TriggerData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* TriggerData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) TriggerData(arena); +} +constexpr auto TriggerData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TriggerData), + alignof(TriggerData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> TriggerData::_class_data_ = { + { + &_TriggerData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TriggerData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TriggerData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &TriggerData::ByteSizeLong, + &TriggerData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TriggerData, _impl_._cached_size_), + true, + }, + "dapi.data.TriggerData", +}; +const ::google::protobuf::internal::ClassData* TriggerData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<2, 4, 0, 0, 2> TriggerData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 4, 24, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967280, // skipmap + offsetof(decltype(_table_), field_entries), + 4, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::TriggerData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // sint32 type = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_)}}, + // uint32 lvl = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_)}}, + // sint32 x = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.x_)}}, + // sint32 y = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.y_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 lvl = 1; + {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 x = 2; + {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 y = 3; + {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 type = 4; + {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void TriggerData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.TriggerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.lvl_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.type_) - + reinterpret_cast(&_impl_.lvl_)) + sizeof(_impl_.type_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* TriggerData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const TriggerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* TriggerData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const TriggerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TriggerData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 lvl = 1; + if (this_._internal_lvl() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_lvl(), target); + } + + // sint32 x = 2; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_x(), target); + } + + // sint32 y = 3; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_y(), target); + } + + // sint32 type = 4; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal_type(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TriggerData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t TriggerData::ByteSizeLong(const MessageLite& base) { + const TriggerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t TriggerData::ByteSizeLong() const { + const TriggerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.TriggerData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // uint32 lvl = 1; + if (this_._internal_lvl() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_lvl()); + } + // sint32 x = 2; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_x()); + } + // sint32 y = 3; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_y()); + } + // sint32 type = 4; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_type()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void TriggerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TriggerData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_lvl() != 0) { + _this->_impl_.lvl_ = from._impl_.lvl_; + } + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TriggerData::CopyFrom(const TriggerData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TriggerData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void TriggerData::InternalSwap(TriggerData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_) + + sizeof(TriggerData::_impl_.type_) + - PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_)>( + reinterpret_cast(&_impl_.lvl_), + reinterpret_cast(&other->_impl_.lvl_)); +} + +// =================================================================== + +class TileData::_Internal { + public: +}; + +TileData::TileData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.TileData) +} +TileData::TileData( + ::google::protobuf::Arena* arena, const TileData& from) + : TileData(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE TileData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void TileData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, type_), + 0, + offsetof(Impl_, y_) - + offsetof(Impl_, type_) + + sizeof(Impl_::y_)); +} +TileData::~TileData() { + // @@protoc_insertion_point(destructor:dapi.data.TileData) + SharedDtor(*this); +} +inline void TileData::SharedDtor(MessageLite& self) { + TileData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* TileData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) TileData(arena); +} +constexpr auto TileData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TileData), + alignof(TileData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<19> TileData::_class_data_ = { + { + &_TileData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TileData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TileData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &TileData::ByteSizeLong, + &TileData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TileData, _impl_._cached_size_), + true, + }, + "dapi.data.TileData", +}; +const ::google::protobuf::internal::ClassData* TileData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 0, 0, 2> TileData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::TileData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // sint32 type = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_)}}, + // bool solid = 2; + {::_pbi::TcParser::FastV8S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.solid_)}}, + // sint32 x = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.x_)}}, + // sint32 y = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_)}}, + // bool stopMissile = 5; + {::_pbi::TcParser::FastV8S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.stopmissile_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // sint32 type = 1; + {PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool solid = 2; + {PROTOBUF_FIELD_OFFSET(TileData, _impl_.solid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // sint32 x = 3; + {PROTOBUF_FIELD_OFFSET(TileData, _impl_.x_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 y = 4; + {PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool stopMissile = 5; + {PROTOBUF_FIELD_OFFSET(TileData, _impl_.stopmissile_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void TileData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.TileData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + ::memset(&_impl_.type_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.y_) - + reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.y_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* TileData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const TileData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* TileData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const TileData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TileData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 type = 1; + if (this_._internal_type() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal_type(), target); + } + + // bool solid = 2; + if (this_._internal_solid() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 2, this_._internal_solid(), target); + } + + // sint32 x = 3; + if (this_._internal_x() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_x(), target); + } + + // sint32 y = 4; + if (this_._internal_y() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal_y(), target); + } + + // bool stopMissile = 5; + if (this_._internal_stopmissile() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal_stopmissile(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TileData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t TileData::ByteSizeLong(const MessageLite& base) { + const TileData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t TileData::ByteSizeLong() const { + const TileData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.TileData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // sint32 type = 1; + if (this_._internal_type() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_type()); + } + // sint32 x = 3; + if (this_._internal_x() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_x()); + } + // bool solid = 2; + if (this_._internal_solid() != 0) { + total_size += 2; + } + // bool stopMissile = 5; + if (this_._internal_stopmissile() != 0) { + total_size += 2; + } + // sint32 y = 4; + if (this_._internal_y() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_y()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void TileData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TileData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_type() != 0) { + _this->_impl_.type_ = from._impl_.type_; + } + if (from._internal_x() != 0) { + _this->_impl_.x_ = from._impl_.x_; + } + if (from._internal_solid() != 0) { + _this->_impl_.solid_ = from._impl_.solid_; + } + if (from._internal_stopmissile() != 0) { + _this->_impl_.stopmissile_ = from._impl_.stopmissile_; + } + if (from._internal_y() != 0) { + _this->_impl_.y_ = from._impl_.y_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TileData::CopyFrom(const TileData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TileData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void TileData::InternalSwap(TileData* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_) + + sizeof(TileData::_impl_.y_) + - PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_)>( + reinterpret_cast(&_impl_.type_), + reinterpret_cast(&other->_impl_.type_)); +} + +// =================================================================== + +class TownerData::_Internal { + public: +}; + +TownerData::TownerData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.TownerData) +} +inline PROTOBUF_NDEBUG_INLINE TownerData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::data::TownerData& from_msg) + : _tname_(arena, from._tname_), + _cached_size_{0} {} + +TownerData::TownerData( + ::google::protobuf::Arena* arena, + const TownerData& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + TownerData* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, id_), + offsetof(Impl_, _ty_) - + offsetof(Impl_, id_) + + sizeof(Impl_::_ty_)); + + // @@protoc_insertion_point(copy_constructor:dapi.data.TownerData) +} +inline PROTOBUF_NDEBUG_INLINE TownerData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _tname_(arena), + _cached_size_{0} {} + +inline void TownerData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, id_), + 0, + offsetof(Impl_, _ty_) - + offsetof(Impl_, id_) + + sizeof(Impl_::_ty_)); +} +TownerData::~TownerData() { + // @@protoc_insertion_point(destructor:dapi.data.TownerData) + SharedDtor(*this); +} +inline void TownerData::SharedDtor(MessageLite& self) { + TownerData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_._tname_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* TownerData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) TownerData(arena); +} +constexpr auto TownerData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TownerData), + alignof(TownerData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> TownerData::_class_data_ = { + { + &_TownerData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &TownerData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &TownerData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &TownerData::ByteSizeLong, + &TownerData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(TownerData, _impl_._cached_size_), + true, + }, + "dapi.data.TownerData", +}; +const ::google::protobuf::internal::ClassData* TownerData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<3, 5, 0, 35, 2> TownerData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 56, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::TownerData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_)}}, + // uint32 _ttype = 2; + {::_pbi::TcParser::FastV32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ttype_)}}, + // sint32 _tx = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tx_)}}, + // sint32 _ty = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_)}}, + // string _tName = 5; + {::_pbi::TcParser::FastUS1, + {42, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tname_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _ttype = 2; + {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ttype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 _tx = 3; + {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _ty = 4; + {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // string _tName = 5; + {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + }}, + // no aux_entries + {{ + "\24\0\0\0\0\6\0\0" + "dapi.data.TownerData" + "_tName" + }}, +}; + +PROTOBUF_NOINLINE void TownerData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.TownerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_._tname_.ClearToEmpty(); + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_._ty_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_._ty_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* TownerData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const TownerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* TownerData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const TownerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TownerData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + // uint32 _ttype = 2; + if (this_._internal__ttype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 2, this_._internal__ttype(), target); + } + + // sint32 _tx = 3; + if (this_._internal__tx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal__tx(), target); + } + + // sint32 _ty = 4; + if (this_._internal__ty() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal__ty(), target); + } + + // string _tName = 5; + if (!this_._internal__tname().empty()) { + const std::string& _s = this_._internal__tname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.TownerData._tName"); + target = stream->WriteStringMaybeAliased(5, _s, target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TownerData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t TownerData::ByteSizeLong(const MessageLite& base) { + const TownerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t TownerData::ByteSizeLong() const { + const TownerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.TownerData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string _tName = 5; + if (!this_._internal__tname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal__tname()); + } + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + // uint32 _ttype = 2; + if (this_._internal__ttype() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal__ttype()); + } + // sint32 _tx = 3; + if (this_._internal__tx() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__tx()); + } + // sint32 _ty = 4; + if (this_._internal__ty() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__ty()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void TownerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TownerData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal__tname().empty()) { + _this->_internal_set__tname(from._internal__tname()); + } + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + if (from._internal__ttype() != 0) { + _this->_impl_._ttype_ = from._impl_._ttype_; + } + if (from._internal__tx() != 0) { + _this->_impl_._tx_ = from._impl_._tx_; + } + if (from._internal__ty() != 0) { + _this->_impl_._ty_ = from._impl_._ty_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void TownerData::CopyFrom(const TownerData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TownerData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void TownerData::InternalSwap(TownerData* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._tname_, &other->_impl_._tname_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_) + + sizeof(TownerData::_impl_._ty_) + - PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +// =================================================================== + +class ItemData::_Internal { + public: +}; + +ItemData::ItemData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.ItemData) +} +inline PROTOBUF_NDEBUG_INLINE ItemData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::data::ItemData& from_msg) + : _iname_(arena, from._iname_), + _iiname_(arena, from._iiname_), + _cached_size_{0} {} + +ItemData::ItemData( + ::google::protobuf::Arena* arena, + const ItemData& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + ItemData* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, id_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, id_), + offsetof(Impl_, ididx_) - + offsetof(Impl_, id_) + + sizeof(Impl_::ididx_)); + + // @@protoc_insertion_point(copy_constructor:dapi.data.ItemData) +} +inline PROTOBUF_NDEBUG_INLINE ItemData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _iname_(arena), + _iiname_(arena), + _cached_size_{0} {} + +inline void ItemData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, id_), + 0, + offsetof(Impl_, ididx_) - + offsetof(Impl_, id_) + + sizeof(Impl_::ididx_)); +} +ItemData::~ItemData() { + // @@protoc_insertion_point(destructor:dapi.data.ItemData) + SharedDtor(*this); +} +inline void ItemData::SharedDtor(MessageLite& self) { + ItemData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_._iname_.Destroy(); + this_._impl_._iiname_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* ItemData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ItemData(arena); +} +constexpr auto ItemData::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ItemData), + alignof(ItemData)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<19> ItemData::_class_data_ = { + { + &_ItemData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ItemData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ItemData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ItemData::ByteSizeLong, + &ItemData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ItemData, _impl_._cached_size_), + true, + }, + "dapi.data.ItemData", +}; +const ::google::protobuf::internal::ClassData* ItemData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 48, 0, 88, 7> ItemData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 48, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 0, // skipmap + offsetof(decltype(_table_), field_entries), + 48, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::ItemData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 ID = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_)}}, + // sint32 _itype = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._itype_)}}, + // sint32 _ix = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ix_)}}, + // sint32 _iy = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iy_)}}, + // bool _iIdentified = 5; + {::_pbi::TcParser::FastV8S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iidentified_)}}, + // uint32 _iMagical = 6; + {::_pbi::TcParser::FastV32S1, + {48, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imagical_)}}, + // string _iName = 7; + {::_pbi::TcParser::FastUS1, + {58, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iname_)}}, + // string _iIName = 8; + {::_pbi::TcParser::FastUS1, + {66, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iiname_)}}, + // uint32 _iClass = 9; + {::_pbi::TcParser::FastV32S1, + {72, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iclass_)}}, + // sint32 _iCurs = 10; + {::_pbi::TcParser::FastZ32S1, + {80, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icurs_)}}, + // sint32 _iValue = 11; + {::_pbi::TcParser::FastZ32S1, + {88, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ivalue_)}}, + // sint32 _iMinDam = 12; + {::_pbi::TcParser::FastZ32S1, + {96, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindam_)}}, + // sint32 _iMaxDam = 13; + {::_pbi::TcParser::FastZ32S1, + {104, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdam_)}}, + // sint32 _iAC = 14; + {::_pbi::TcParser::FastZ32S1, + {112, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iac_)}}, + // sint32 _iFlags = 15; + {::_pbi::TcParser::FastZ32S1, + {120, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iflags_)}}, + // sint32 _iMiscId = 16; + {::_pbi::TcParser::FastZ32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imiscid_)}}, + // sint32 _iSpell = 17; + {::_pbi::TcParser::FastZ32S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispell_)}}, + // sint32 _iCharges = 18; + {::_pbi::TcParser::FastZ32S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icharges_)}}, + // sint32 _iMaxCharges = 19; + {::_pbi::TcParser::FastZ32S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxcharges_)}}, + // sint32 _iDurability = 20; + {::_pbi::TcParser::FastZ32S2, + {416, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._idurability_)}}, + // sint32 _iMaxDur = 21; + {::_pbi::TcParser::FastZ32S2, + {424, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdur_)}}, + // sint32 _iPLDam = 22; + {::_pbi::TcParser::FastZ32S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldam_)}}, + // sint32 _iPLToHit = 23; + {::_pbi::TcParser::FastZ32S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipltohit_)}}, + // sint32 _iPLAC = 24; + {::_pbi::TcParser::FastZ32S2, + {448, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplac_)}}, + // sint32 _iPLStr = 25; + {::_pbi::TcParser::FastZ32S2, + {456, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplstr_)}}, + // sint32 _iPLMag = 26; + {::_pbi::TcParser::FastZ32S2, + {464, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmag_)}}, + // sint32 _iPLDex = 27; + {::_pbi::TcParser::FastZ32S2, + {472, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldex_)}}, + // sint32 _iPLVit = 28; + {::_pbi::TcParser::FastZ32S2, + {480, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplvit_)}}, + // sint32 _iPLFR = 29; + {::_pbi::TcParser::FastZ32S2, + {488, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplfr_)}}, + // sint32 _iPLLR = 30; + {::_pbi::TcParser::FastZ32S2, + {496, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllr_)}}, + // sint32 _iPLMR = 31; + {::_pbi::TcParser::FastZ32S2, + {504, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmr_)}}, + }}, {{ + 33, 0, 1, + 0, 32, + 65535, 65535 + }}, {{ + // uint32 ID = 1; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 _itype = 2; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._itype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _ix = 3; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ix_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iy = 4; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iy_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool _iIdentified = 5; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iidentified_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 _iMagical = 6; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imagical_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // string _iName = 7; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // string _iIName = 8; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iiname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 _iClass = 9; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iclass_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 _iCurs = 10; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icurs_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iValue = 11; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ivalue_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMinDam = 12; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMaxDam = 13; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iAC = 14; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iac_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iFlags = 15; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iflags_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMiscId = 16; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imiscid_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iSpell = 17; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispell_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iCharges = 18; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icharges_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMaxCharges = 19; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxcharges_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iDurability = 20; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._idurability_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMaxDur = 21; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdur_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLDam = 22; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLToHit = 23; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipltohit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLAC = 24; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplac_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLStr = 25; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplstr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLMag = 26; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLDex = 27; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldex_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLVit = 28; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplvit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLFR = 29; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplfr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLLR = 30; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLMR = 31; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLMana = 32; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmana_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLHP = 33; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplhp_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLDamMod = 34; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldammod_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLGetHit = 35; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplgethit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPLLight = 36; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllight_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iSplLvlAdd = 37; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispllvladd_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iFMinDam = 38; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ifmindam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iFMaxDam = 39; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ifmaxdam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iLMinDam = 40; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ilmindam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iLMaxDam = 41; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ilmaxdam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iPrePower = 42; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iprepower_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iSufPower = 43; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._isufpower_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMinStr = 44; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iminstr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMinMag = 45; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iminmag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _iMinDex = 46; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindex_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool _iStatFlag = 47; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._istatflag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // sint32 IDidx = 48; + {PROTOBUF_FIELD_OFFSET(ItemData, _impl_.ididx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + }}, + // no aux_entries + {{ + "\22\0\0\0\0\0\0\6\7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "dapi.data.ItemData" + "_iName" + "_iIName" + }}, +}; + +PROTOBUF_NOINLINE void ItemData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.ItemData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_._iname_.ClearToEmpty(); + _impl_._iiname_.ClearToEmpty(); + ::memset(&_impl_.id_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.ididx_) - + reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.ididx_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ItemData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ItemData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ItemData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ItemData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.ItemData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 ID = 1; + if (this_._internal_id() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_id(), target); + } + + // sint32 _itype = 2; + if (this_._internal__itype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal__itype(), target); + } + + // sint32 _ix = 3; + if (this_._internal__ix() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal__ix(), target); + } + + // sint32 _iy = 4; + if (this_._internal__iy() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal__iy(), target); + } + + // bool _iIdentified = 5; + if (this_._internal__iidentified() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 5, this_._internal__iidentified(), target); + } + + // uint32 _iMagical = 6; + if (this_._internal__imagical() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 6, this_._internal__imagical(), target); + } + + // string _iName = 7; + if (!this_._internal__iname().empty()) { + const std::string& _s = this_._internal__iname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.ItemData._iName"); + target = stream->WriteStringMaybeAliased(7, _s, target); + } + + // string _iIName = 8; + if (!this_._internal__iiname().empty()) { + const std::string& _s = this_._internal__iiname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.ItemData._iIName"); + target = stream->WriteStringMaybeAliased(8, _s, target); + } + + // uint32 _iClass = 9; + if (this_._internal__iclass() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 9, this_._internal__iclass(), target); + } + + // sint32 _iCurs = 10; + if (this_._internal__icurs() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 10, this_._internal__icurs(), target); + } + + // sint32 _iValue = 11; + if (this_._internal__ivalue() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 11, this_._internal__ivalue(), target); + } + + // sint32 _iMinDam = 12; + if (this_._internal__imindam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 12, this_._internal__imindam(), target); + } + + // sint32 _iMaxDam = 13; + if (this_._internal__imaxdam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 13, this_._internal__imaxdam(), target); + } + + // sint32 _iAC = 14; + if (this_._internal__iac() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 14, this_._internal__iac(), target); + } + + // sint32 _iFlags = 15; + if (this_._internal__iflags() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 15, this_._internal__iflags(), target); + } + + // sint32 _iMiscId = 16; + if (this_._internal__imiscid() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 16, this_._internal__imiscid(), target); + } + + // sint32 _iSpell = 17; + if (this_._internal__ispell() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 17, this_._internal__ispell(), target); + } + + // sint32 _iCharges = 18; + if (this_._internal__icharges() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 18, this_._internal__icharges(), target); + } + + // sint32 _iMaxCharges = 19; + if (this_._internal__imaxcharges() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 19, this_._internal__imaxcharges(), target); + } + + // sint32 _iDurability = 20; + if (this_._internal__idurability() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 20, this_._internal__idurability(), target); + } + + // sint32 _iMaxDur = 21; + if (this_._internal__imaxdur() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 21, this_._internal__imaxdur(), target); + } + + // sint32 _iPLDam = 22; + if (this_._internal__ipldam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 22, this_._internal__ipldam(), target); + } + + // sint32 _iPLToHit = 23; + if (this_._internal__ipltohit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 23, this_._internal__ipltohit(), target); + } + + // sint32 _iPLAC = 24; + if (this_._internal__iplac() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 24, this_._internal__iplac(), target); + } + + // sint32 _iPLStr = 25; + if (this_._internal__iplstr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 25, this_._internal__iplstr(), target); + } + + // sint32 _iPLMag = 26; + if (this_._internal__iplmag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 26, this_._internal__iplmag(), target); + } + + // sint32 _iPLDex = 27; + if (this_._internal__ipldex() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 27, this_._internal__ipldex(), target); + } + + // sint32 _iPLVit = 28; + if (this_._internal__iplvit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 28, this_._internal__iplvit(), target); + } + + // sint32 _iPLFR = 29; + if (this_._internal__iplfr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 29, this_._internal__iplfr(), target); + } + + // sint32 _iPLLR = 30; + if (this_._internal__ipllr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 30, this_._internal__ipllr(), target); + } + + // sint32 _iPLMR = 31; + if (this_._internal__iplmr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 31, this_._internal__iplmr(), target); + } + + // sint32 _iPLMana = 32; + if (this_._internal__iplmana() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 32, this_._internal__iplmana(), target); + } + + // sint32 _iPLHP = 33; + if (this_._internal__iplhp() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 33, this_._internal__iplhp(), target); + } + + // sint32 _iPLDamMod = 34; + if (this_._internal__ipldammod() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 34, this_._internal__ipldammod(), target); + } + + // sint32 _iPLGetHit = 35; + if (this_._internal__iplgethit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 35, this_._internal__iplgethit(), target); + } + + // sint32 _iPLLight = 36; + if (this_._internal__ipllight() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 36, this_._internal__ipllight(), target); + } + + // sint32 _iSplLvlAdd = 37; + if (this_._internal__ispllvladd() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 37, this_._internal__ispllvladd(), target); + } + + // sint32 _iFMinDam = 38; + if (this_._internal__ifmindam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 38, this_._internal__ifmindam(), target); + } + + // sint32 _iFMaxDam = 39; + if (this_._internal__ifmaxdam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 39, this_._internal__ifmaxdam(), target); + } + + // sint32 _iLMinDam = 40; + if (this_._internal__ilmindam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 40, this_._internal__ilmindam(), target); + } + + // sint32 _iLMaxDam = 41; + if (this_._internal__ilmaxdam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 41, this_._internal__ilmaxdam(), target); + } + + // sint32 _iPrePower = 42; + if (this_._internal__iprepower() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 42, this_._internal__iprepower(), target); + } + + // sint32 _iSufPower = 43; + if (this_._internal__isufpower() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 43, this_._internal__isufpower(), target); + } + + // sint32 _iMinStr = 44; + if (this_._internal__iminstr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 44, this_._internal__iminstr(), target); + } + + // sint32 _iMinMag = 45; + if (this_._internal__iminmag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 45, this_._internal__iminmag(), target); + } + + // sint32 _iMinDex = 46; + if (this_._internal__imindex() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 46, this_._internal__imindex(), target); + } + + // bool _iStatFlag = 47; + if (this_._internal__istatflag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 47, this_._internal__istatflag(), target); + } + + // sint32 IDidx = 48; + if (this_._internal_ididx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 48, this_._internal_ididx(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.ItemData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ItemData::ByteSizeLong(const MessageLite& base) { + const ItemData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ItemData::ByteSizeLong() const { + const ItemData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.ItemData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // string _iName = 7; + if (!this_._internal__iname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal__iname()); + } + // string _iIName = 8; + if (!this_._internal__iiname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal__iiname()); + } + // uint32 ID = 1; + if (this_._internal_id() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_id()); + } + // sint32 _itype = 2; + if (this_._internal__itype() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__itype()); + } + // sint32 _ix = 3; + if (this_._internal__ix() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__ix()); + } + // sint32 _iy = 4; + if (this_._internal__iy() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__iy()); + } + // uint32 _iMagical = 6; + if (this_._internal__imagical() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal__imagical()); + } + // uint32 _iClass = 9; + if (this_._internal__iclass() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal__iclass()); + } + // sint32 _iCurs = 10; + if (this_._internal__icurs() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__icurs()); + } + // sint32 _iValue = 11; + if (this_._internal__ivalue() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__ivalue()); + } + // sint32 _iMinDam = 12; + if (this_._internal__imindam() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__imindam()); + } + // sint32 _iMaxDam = 13; + if (this_._internal__imaxdam() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__imaxdam()); + } + // sint32 _iAC = 14; + if (this_._internal__iac() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__iac()); + } + // sint32 _iFlags = 15; + if (this_._internal__iflags() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__iflags()); + } + // sint32 _iMiscId = 16; + if (this_._internal__imiscid() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__imiscid()); + } + // sint32 _iSpell = 17; + if (this_._internal__ispell() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ispell()); + } + // sint32 _iCharges = 18; + if (this_._internal__icharges() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__icharges()); + } + // sint32 _iMaxCharges = 19; + if (this_._internal__imaxcharges() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__imaxcharges()); + } + // sint32 _iDurability = 20; + if (this_._internal__idurability() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__idurability()); + } + // sint32 _iMaxDur = 21; + if (this_._internal__imaxdur() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__imaxdur()); + } + // sint32 _iPLDam = 22; + if (this_._internal__ipldam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipldam()); + } + // sint32 _iPLToHit = 23; + if (this_._internal__ipltohit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipltohit()); + } + // sint32 _iPLAC = 24; + if (this_._internal__iplac() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplac()); + } + // sint32 _iPLStr = 25; + if (this_._internal__iplstr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplstr()); + } + // sint32 _iPLMag = 26; + if (this_._internal__iplmag() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplmag()); + } + // bool _iIdentified = 5; + if (this_._internal__iidentified() != 0) { + total_size += 2; + } + // bool _iStatFlag = 47; + if (this_._internal__istatflag() != 0) { + total_size += 3; + } + // sint32 _iPLDex = 27; + if (this_._internal__ipldex() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipldex()); + } + // sint32 _iPLVit = 28; + if (this_._internal__iplvit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplvit()); + } + // sint32 _iPLFR = 29; + if (this_._internal__iplfr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplfr()); + } + // sint32 _iPLLR = 30; + if (this_._internal__ipllr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipllr()); + } + // sint32 _iPLMR = 31; + if (this_._internal__iplmr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplmr()); + } + // sint32 _iPLMana = 32; + if (this_._internal__iplmana() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplmana()); + } + // sint32 _iPLHP = 33; + if (this_._internal__iplhp() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplhp()); + } + // sint32 _iPLDamMod = 34; + if (this_._internal__ipldammod() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipldammod()); + } + // sint32 _iPLGetHit = 35; + if (this_._internal__iplgethit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iplgethit()); + } + // sint32 _iPLLight = 36; + if (this_._internal__ipllight() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ipllight()); + } + // sint32 _iSplLvlAdd = 37; + if (this_._internal__ispllvladd() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ispllvladd()); + } + // sint32 _iFMinDam = 38; + if (this_._internal__ifmindam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ifmindam()); + } + // sint32 _iFMaxDam = 39; + if (this_._internal__ifmaxdam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ifmaxdam()); + } + // sint32 _iLMinDam = 40; + if (this_._internal__ilmindam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ilmindam()); + } + // sint32 _iLMaxDam = 41; + if (this_._internal__ilmaxdam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__ilmaxdam()); + } + // sint32 _iPrePower = 42; + if (this_._internal__iprepower() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iprepower()); + } + // sint32 _iSufPower = 43; + if (this_._internal__isufpower() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__isufpower()); + } + // sint32 _iMinStr = 44; + if (this_._internal__iminstr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iminstr()); + } + // sint32 _iMinMag = 45; + if (this_._internal__iminmag() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__iminmag()); + } + // sint32 _iMinDex = 46; + if (this_._internal__imindex() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__imindex()); + } + // sint32 IDidx = 48; + if (this_._internal_ididx() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal_ididx()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ItemData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.ItemData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (!from._internal__iname().empty()) { + _this->_internal_set__iname(from._internal__iname()); + } + if (!from._internal__iiname().empty()) { + _this->_internal_set__iiname(from._internal__iiname()); + } + if (from._internal_id() != 0) { + _this->_impl_.id_ = from._impl_.id_; + } + if (from._internal__itype() != 0) { + _this->_impl_._itype_ = from._impl_._itype_; + } + if (from._internal__ix() != 0) { + _this->_impl_._ix_ = from._impl_._ix_; + } + if (from._internal__iy() != 0) { + _this->_impl_._iy_ = from._impl_._iy_; + } + if (from._internal__imagical() != 0) { + _this->_impl_._imagical_ = from._impl_._imagical_; + } + if (from._internal__iclass() != 0) { + _this->_impl_._iclass_ = from._impl_._iclass_; + } + if (from._internal__icurs() != 0) { + _this->_impl_._icurs_ = from._impl_._icurs_; + } + if (from._internal__ivalue() != 0) { + _this->_impl_._ivalue_ = from._impl_._ivalue_; + } + if (from._internal__imindam() != 0) { + _this->_impl_._imindam_ = from._impl_._imindam_; + } + if (from._internal__imaxdam() != 0) { + _this->_impl_._imaxdam_ = from._impl_._imaxdam_; + } + if (from._internal__iac() != 0) { + _this->_impl_._iac_ = from._impl_._iac_; + } + if (from._internal__iflags() != 0) { + _this->_impl_._iflags_ = from._impl_._iflags_; + } + if (from._internal__imiscid() != 0) { + _this->_impl_._imiscid_ = from._impl_._imiscid_; + } + if (from._internal__ispell() != 0) { + _this->_impl_._ispell_ = from._impl_._ispell_; + } + if (from._internal__icharges() != 0) { + _this->_impl_._icharges_ = from._impl_._icharges_; + } + if (from._internal__imaxcharges() != 0) { + _this->_impl_._imaxcharges_ = from._impl_._imaxcharges_; + } + if (from._internal__idurability() != 0) { + _this->_impl_._idurability_ = from._impl_._idurability_; + } + if (from._internal__imaxdur() != 0) { + _this->_impl_._imaxdur_ = from._impl_._imaxdur_; + } + if (from._internal__ipldam() != 0) { + _this->_impl_._ipldam_ = from._impl_._ipldam_; + } + if (from._internal__ipltohit() != 0) { + _this->_impl_._ipltohit_ = from._impl_._ipltohit_; + } + if (from._internal__iplac() != 0) { + _this->_impl_._iplac_ = from._impl_._iplac_; + } + if (from._internal__iplstr() != 0) { + _this->_impl_._iplstr_ = from._impl_._iplstr_; + } + if (from._internal__iplmag() != 0) { + _this->_impl_._iplmag_ = from._impl_._iplmag_; + } + if (from._internal__iidentified() != 0) { + _this->_impl_._iidentified_ = from._impl_._iidentified_; + } + if (from._internal__istatflag() != 0) { + _this->_impl_._istatflag_ = from._impl_._istatflag_; + } + if (from._internal__ipldex() != 0) { + _this->_impl_._ipldex_ = from._impl_._ipldex_; + } + if (from._internal__iplvit() != 0) { + _this->_impl_._iplvit_ = from._impl_._iplvit_; + } + if (from._internal__iplfr() != 0) { + _this->_impl_._iplfr_ = from._impl_._iplfr_; + } + if (from._internal__ipllr() != 0) { + _this->_impl_._ipllr_ = from._impl_._ipllr_; + } + if (from._internal__iplmr() != 0) { + _this->_impl_._iplmr_ = from._impl_._iplmr_; + } + if (from._internal__iplmana() != 0) { + _this->_impl_._iplmana_ = from._impl_._iplmana_; + } + if (from._internal__iplhp() != 0) { + _this->_impl_._iplhp_ = from._impl_._iplhp_; + } + if (from._internal__ipldammod() != 0) { + _this->_impl_._ipldammod_ = from._impl_._ipldammod_; + } + if (from._internal__iplgethit() != 0) { + _this->_impl_._iplgethit_ = from._impl_._iplgethit_; + } + if (from._internal__ipllight() != 0) { + _this->_impl_._ipllight_ = from._impl_._ipllight_; + } + if (from._internal__ispllvladd() != 0) { + _this->_impl_._ispllvladd_ = from._impl_._ispllvladd_; + } + if (from._internal__ifmindam() != 0) { + _this->_impl_._ifmindam_ = from._impl_._ifmindam_; + } + if (from._internal__ifmaxdam() != 0) { + _this->_impl_._ifmaxdam_ = from._impl_._ifmaxdam_; + } + if (from._internal__ilmindam() != 0) { + _this->_impl_._ilmindam_ = from._impl_._ilmindam_; + } + if (from._internal__ilmaxdam() != 0) { + _this->_impl_._ilmaxdam_ = from._impl_._ilmaxdam_; + } + if (from._internal__iprepower() != 0) { + _this->_impl_._iprepower_ = from._impl_._iprepower_; + } + if (from._internal__isufpower() != 0) { + _this->_impl_._isufpower_ = from._impl_._isufpower_; + } + if (from._internal__iminstr() != 0) { + _this->_impl_._iminstr_ = from._impl_._iminstr_; + } + if (from._internal__iminmag() != 0) { + _this->_impl_._iminmag_ = from._impl_._iminmag_; + } + if (from._internal__imindex() != 0) { + _this->_impl_._imindex_ = from._impl_._imindex_; + } + if (from._internal_ididx() != 0) { + _this->_impl_.ididx_ = from._impl_.ididx_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ItemData::CopyFrom(const ItemData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.ItemData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ItemData::InternalSwap(ItemData* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._iname_, &other->_impl_._iname_, arena); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._iiname_, &other->_impl_._iiname_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(ItemData, _impl_.ididx_) + + sizeof(ItemData::_impl_.ididx_) + - PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_)>( + reinterpret_cast(&_impl_.id_), + reinterpret_cast(&other->_impl_.id_)); +} + +// =================================================================== + +class PlayerData::_Internal { + public: +}; + +PlayerData::PlayerData(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.data.PlayerData) +} +inline PROTOBUF_NDEBUG_INLINE PlayerData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::data::PlayerData& from_msg) + : _pspllvl_{visibility, arena, from._pspllvl_}, + __pspllvl_cached_byte_size_{0}, + invbody_{visibility, arena, from.invbody_}, + _invbody_cached_byte_size_{0}, + invlist_{visibility, arena, from.invlist_}, + _invlist_cached_byte_size_{0}, + invgrid_{visibility, arena, from.invgrid_}, + _invgrid_cached_byte_size_{0}, + spdlist_{visibility, arena, from.spdlist_}, + _spdlist_cached_byte_size_{0}, + _pname_(arena, from._pname_), + _cached_size_{0} {} + +PlayerData::PlayerData( + ::google::protobuf::Arena* arena, + const PlayerData& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + PlayerData* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, _pmode_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, _pmode_), + offsetof(Impl_, pmanashield_) - + offsetof(Impl_, _pmode_) + + sizeof(Impl_::pmanashield_)); + + // @@protoc_insertion_point(copy_constructor:dapi.data.PlayerData) +} +inline PROTOBUF_NDEBUG_INLINE PlayerData::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _pspllvl_{visibility, arena}, + __pspllvl_cached_byte_size_{0}, + invbody_{visibility, arena}, + _invbody_cached_byte_size_{0}, + invlist_{visibility, arena}, + _invlist_cached_byte_size_{0}, + invgrid_{visibility, arena}, + _invgrid_cached_byte_size_{0}, + spdlist_{visibility, arena}, + _spdlist_cached_byte_size_{0}, + _pname_(arena), + _cached_size_{0} {} + +inline void PlayerData::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, _pmode_), + 0, + offsetof(Impl_, pmanashield_) - + offsetof(Impl_, _pmode_) + + sizeof(Impl_::pmanashield_)); +} +PlayerData::~PlayerData() { + // @@protoc_insertion_point(destructor:dapi.data.PlayerData) + SharedDtor(*this); +} +inline void PlayerData::SharedDtor(MessageLite& self) { + PlayerData& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_._pname_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* PlayerData::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) PlayerData(arena); +} +constexpr auto PlayerData::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_) + + decltype(PlayerData::_impl_._pspllvl_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invbody_) + + decltype(PlayerData::_impl_.invbody_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invlist_) + + decltype(PlayerData::_impl_.invlist_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invgrid_) + + decltype(PlayerData::_impl_.invgrid_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.spdlist_) + + decltype(PlayerData::_impl_.spdlist_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(PlayerData), alignof(PlayerData), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&PlayerData::PlacementNew_, + sizeof(PlayerData), + alignof(PlayerData)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> PlayerData::_class_data_ = { + { + &_PlayerData_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &PlayerData::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &PlayerData::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &PlayerData::ByteSizeLong, + &PlayerData::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._cached_size_), + true, + }, + "dapi.data.PlayerData", +}; +const ::google::protobuf::internal::ClassData* PlayerData::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 50, 0, 83, 9> PlayerData::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 50, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 0, // skipmap + offsetof(decltype(_table_), field_entries), + 50, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::data::PlayerData>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // sint32 _pmode = 1; + {::_pbi::TcParser::FastZ32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_)}}, + // sint32 pnum = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pnum_)}}, + // sint32 plrlevel = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.plrlevel_)}}, + // sint32 _px = 4; + {::_pbi::TcParser::FastZ32S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._px_)}}, + // sint32 _py = 5; + {::_pbi::TcParser::FastZ32S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._py_)}}, + // sint32 _pfutx = 6; + {::_pbi::TcParser::FastZ32S1, + {48, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfutx_)}}, + // sint32 _pfuty = 7; + {::_pbi::TcParser::FastZ32S1, + {56, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfuty_)}}, + // sint32 _pdir = 8; + {::_pbi::TcParser::FastZ32S1, + {64, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdir_)}}, + // sint32 _pRSpell = 9; + {::_pbi::TcParser::FastZ32S1, + {72, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspell_)}}, + // uint32 _pRsplType = 10; + {::_pbi::TcParser::FastV32S1, + {80, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspltype_)}}, + // repeated uint32 _pSplLvl = 11; + {::_pbi::TcParser::FastV32P1, + {90, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_)}}, + // uint64 _pMemSpells = 12; + {::_pbi::TcParser::FastV64S1, + {96, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmemspells_)}}, + // uint64 _pAblSpells = 13; + {::_pbi::TcParser::FastV64S1, + {104, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pablspells_)}}, + // uint64 _pScrlSpells = 14; + {::_pbi::TcParser::FastV64S1, + {112, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pscrlspells_)}}, + // string _pName = 15; + {::_pbi::TcParser::FastUS1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pname_)}}, + // uint32 _pClass = 16; + {::_pbi::TcParser::FastV32S2, + {384, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pclass_)}}, + // uint32 _pStrength = 17; + {::_pbi::TcParser::FastV32S2, + {392, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstrength_)}}, + // uint32 _pBaseStr = 18; + {::_pbi::TcParser::FastV32S2, + {400, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasestr_)}}, + // uint32 _pMagic = 19; + {::_pbi::TcParser::FastV32S2, + {408, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagic_)}}, + // uint32 _pBaseMag = 20; + {::_pbi::TcParser::FastV32S2, + {416, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasemag_)}}, + // uint32 _pDexterity = 21; + {::_pbi::TcParser::FastV32S2, + {424, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdexterity_)}}, + // uint32 _pBaseDex = 22; + {::_pbi::TcParser::FastV32S2, + {432, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasedex_)}}, + // uint32 _pVitality = 23; + {::_pbi::TcParser::FastV32S2, + {440, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pvitality_)}}, + // uint32 _pBaseVit = 24; + {::_pbi::TcParser::FastV32S2, + {448, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasevit_)}}, + // uint32 _pStatPts = 25; + {::_pbi::TcParser::FastV32S2, + {456, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstatpts_)}}, + // uint32 _pDamageMod = 26; + {::_pbi::TcParser::FastV32S2, + {464, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdamagemod_)}}, + // uint32 _pHitPoints = 27; + {::_pbi::TcParser::FastV32S2, + {472, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._phitpoints_)}}, + // uint32 _pMaxHP = 28; + {::_pbi::TcParser::FastV32S2, + {480, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxhp_)}}, + // sint32 _pMana = 29; + {::_pbi::TcParser::FastZ32S2, + {488, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmana_)}}, + // uint32 _pMaxMana = 30; + {::_pbi::TcParser::FastV32S2, + {496, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxmana_)}}, + // uint32 _pLevel = 31; + {::_pbi::TcParser::FastV32S2, + {504, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plevel_)}}, + }}, {{ + 33, 0, 2, + 0, 32, 65532, 48, + 65535, 65535 + }}, {{ + // sint32 _pmode = 1; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 pnum = 2; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pnum_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 plrlevel = 3; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.plrlevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _px = 4; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._px_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _py = 5; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._py_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _pfutx = 6; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfutx_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _pfuty = 7; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfuty_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _pdir = 8; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdir_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 _pRSpell = 9; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspell_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // uint32 _pRsplType = 10; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspltype_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // repeated uint32 _pSplLvl = 11; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, + // uint64 _pMemSpells = 12; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmemspells_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint64 _pAblSpells = 13; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pablspells_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // uint64 _pScrlSpells = 14; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pscrlspells_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, + // string _pName = 15; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pname_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 _pClass = 16; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pclass_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pStrength = 17; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstrength_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pBaseStr = 18; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasestr_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pMagic = 19; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagic_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pBaseMag = 20; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasemag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pDexterity = 21; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdexterity_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pBaseDex = 22; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasedex_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pVitality = 23; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pvitality_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pBaseVit = 24; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasevit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pStatPts = 25; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstatpts_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pDamageMod = 26; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdamagemod_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pHitPoints = 27; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._phitpoints_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pMaxHP = 28; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxhp_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 _pMana = 29; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmana_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // uint32 _pMaxMana = 30; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxmana_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pLevel = 31; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pExperience = 32; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pexperience_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pArmorClass = 33; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._parmorclass_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pMagResist = 34; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagresist_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pFireResist = 35; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfireresist_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pLightResist = 36; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plightresist_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pGold = 37; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pgold_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // repeated sint32 InvBody = 38; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invbody_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, + // repeated sint32 InvList = 39; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invlist_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, + // repeated sint32 InvGrid = 40; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invgrid_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, + // repeated sint32 SpdList = 41; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.spdlist_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, + // sint32 HoldItem = 42; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.holditem_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // uint32 _pIAC = 43; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._piac_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIMinDam = 44; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pimindam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIMaxDam = 45; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pimaxdam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIBonusDam = 46; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusdam_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIBonusToHit = 47; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonustohit_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIBonusAC = 48; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusac_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 _pIBonusDamMod = 49; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusdammod_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // bool pManaShield = 50; + {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pmanashield_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + }}, + // no aux_entries + {{ + "\24\0\0\0\0\0\0\0\0\0\0\0\0\0\0\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "dapi.data.PlayerData" + "_pName" + }}, +}; + +PROTOBUF_NOINLINE void PlayerData::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.data.PlayerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_._pspllvl_.Clear(); + _impl_.invbody_.Clear(); + _impl_.invlist_.Clear(); + _impl_.invgrid_.Clear(); + _impl_.spdlist_.Clear(); + _impl_._pname_.ClearToEmpty(); + ::memset(&_impl_._pmode_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.pmanashield_) - + reinterpret_cast(&_impl_._pmode_)) + sizeof(_impl_.pmanashield_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* PlayerData::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const PlayerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* PlayerData::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const PlayerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.data.PlayerData) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // sint32 _pmode = 1; + if (this_._internal__pmode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 1, this_._internal__pmode(), target); + } + + // sint32 pnum = 2; + if (this_._internal_pnum() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_pnum(), target); + } + + // sint32 plrlevel = 3; + if (this_._internal_plrlevel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_plrlevel(), target); + } + + // sint32 _px = 4; + if (this_._internal__px() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 4, this_._internal__px(), target); + } + + // sint32 _py = 5; + if (this_._internal__py() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 5, this_._internal__py(), target); + } + + // sint32 _pfutx = 6; + if (this_._internal__pfutx() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 6, this_._internal__pfutx(), target); + } + + // sint32 _pfuty = 7; + if (this_._internal__pfuty() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 7, this_._internal__pfuty(), target); + } + + // sint32 _pdir = 8; + if (this_._internal__pdir() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 8, this_._internal__pdir(), target); + } + + // sint32 _pRSpell = 9; + if (this_._internal__prspell() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 9, this_._internal__prspell(), target); + } + + // uint32 _pRsplType = 10; + if (this_._internal__prspltype() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this_._internal__prspltype(), target); + } + + // repeated uint32 _pSplLvl = 11; + { + int byte_size = this_._impl_.__pspllvl_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 11, this_._internal__pspllvl(), byte_size, target); + } + } + + // uint64 _pMemSpells = 12; + if (this_._internal__pmemspells() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 12, this_._internal__pmemspells(), target); + } + + // uint64 _pAblSpells = 13; + if (this_._internal__pablspells() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 13, this_._internal__pablspells(), target); + } + + // uint64 _pScrlSpells = 14; + if (this_._internal__pscrlspells() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt64ToArray( + 14, this_._internal__pscrlspells(), target); + } + + // string _pName = 15; + if (!this_._internal__pname().empty()) { + const std::string& _s = this_._internal__pname(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.PlayerData._pName"); + target = stream->WriteStringMaybeAliased(15, _s, target); + } + + // uint32 _pClass = 16; + if (this_._internal__pclass() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 16, this_._internal__pclass(), target); + } + + // uint32 _pStrength = 17; + if (this_._internal__pstrength() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 17, this_._internal__pstrength(), target); + } + + // uint32 _pBaseStr = 18; + if (this_._internal__pbasestr() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 18, this_._internal__pbasestr(), target); + } + + // uint32 _pMagic = 19; + if (this_._internal__pmagic() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 19, this_._internal__pmagic(), target); + } + + // uint32 _pBaseMag = 20; + if (this_._internal__pbasemag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 20, this_._internal__pbasemag(), target); + } + + // uint32 _pDexterity = 21; + if (this_._internal__pdexterity() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 21, this_._internal__pdexterity(), target); + } + + // uint32 _pBaseDex = 22; + if (this_._internal__pbasedex() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 22, this_._internal__pbasedex(), target); + } + + // uint32 _pVitality = 23; + if (this_._internal__pvitality() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 23, this_._internal__pvitality(), target); + } + + // uint32 _pBaseVit = 24; + if (this_._internal__pbasevit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 24, this_._internal__pbasevit(), target); + } + + // uint32 _pStatPts = 25; + if (this_._internal__pstatpts() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 25, this_._internal__pstatpts(), target); + } + + // uint32 _pDamageMod = 26; + if (this_._internal__pdamagemod() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 26, this_._internal__pdamagemod(), target); + } + + // uint32 _pHitPoints = 27; + if (this_._internal__phitpoints() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 27, this_._internal__phitpoints(), target); + } + + // uint32 _pMaxHP = 28; + if (this_._internal__pmaxhp() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 28, this_._internal__pmaxhp(), target); + } + + // sint32 _pMana = 29; + if (this_._internal__pmana() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 29, this_._internal__pmana(), target); + } + + // uint32 _pMaxMana = 30; + if (this_._internal__pmaxmana() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 30, this_._internal__pmaxmana(), target); + } + + // uint32 _pLevel = 31; + if (this_._internal__plevel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 31, this_._internal__plevel(), target); + } + + // uint32 _pExperience = 32; + if (this_._internal__pexperience() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 32, this_._internal__pexperience(), target); + } + + // uint32 _pArmorClass = 33; + if (this_._internal__parmorclass() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 33, this_._internal__parmorclass(), target); + } + + // uint32 _pMagResist = 34; + if (this_._internal__pmagresist() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 34, this_._internal__pmagresist(), target); + } + + // uint32 _pFireResist = 35; + if (this_._internal__pfireresist() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 35, this_._internal__pfireresist(), target); + } + + // uint32 _pLightResist = 36; + if (this_._internal__plightresist() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 36, this_._internal__plightresist(), target); + } + + // uint32 _pGold = 37; + if (this_._internal__pgold() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 37, this_._internal__pgold(), target); + } + + // repeated sint32 InvBody = 38; + { + int byte_size = this_._impl_._invbody_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteSInt32Packed( + 38, this_._internal_invbody(), byte_size, target); + } + } + + // repeated sint32 InvList = 39; + { + int byte_size = this_._impl_._invlist_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteSInt32Packed( + 39, this_._internal_invlist(), byte_size, target); + } + } + + // repeated sint32 InvGrid = 40; + { + int byte_size = this_._impl_._invgrid_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteSInt32Packed( + 40, this_._internal_invgrid(), byte_size, target); + } + } + + // repeated sint32 SpdList = 41; + { + int byte_size = this_._impl_._spdlist_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteSInt32Packed( + 41, this_._internal_spdlist(), byte_size, target); + } + } + + // sint32 HoldItem = 42; + if (this_._internal_holditem() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 42, this_._internal_holditem(), target); + } + + // uint32 _pIAC = 43; + if (this_._internal__piac() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 43, this_._internal__piac(), target); + } + + // uint32 _pIMinDam = 44; + if (this_._internal__pimindam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 44, this_._internal__pimindam(), target); + } + + // uint32 _pIMaxDam = 45; + if (this_._internal__pimaxdam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 45, this_._internal__pimaxdam(), target); + } + + // uint32 _pIBonusDam = 46; + if (this_._internal__pibonusdam() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 46, this_._internal__pibonusdam(), target); + } + + // uint32 _pIBonusToHit = 47; + if (this_._internal__pibonustohit() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 47, this_._internal__pibonustohit(), target); + } + + // uint32 _pIBonusAC = 48; + if (this_._internal__pibonusac() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 48, this_._internal__pibonusac(), target); + } + + // uint32 _pIBonusDamMod = 49; + if (this_._internal__pibonusdammod() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 49, this_._internal__pibonusdammod(), target); + } + + // bool pManaShield = 50; + if (this_._internal_pmanashield() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 50, this_._internal_pmanashield(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.data.PlayerData) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t PlayerData::ByteSizeLong(const MessageLite& base) { + const PlayerData& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t PlayerData::ByteSizeLong() const { + const PlayerData& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.data.PlayerData) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated uint32 _pSplLvl = 11; + { + total_size += + ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( + this_._internal__pspllvl(), 1, + this_._impl_.__pspllvl_cached_byte_size_); + } + // repeated sint32 InvBody = 38; + { + total_size += + ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( + this_._internal_invbody(), 2, + this_._impl_._invbody_cached_byte_size_); + } + // repeated sint32 InvList = 39; + { + total_size += + ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( + this_._internal_invlist(), 2, + this_._impl_._invlist_cached_byte_size_); + } + // repeated sint32 InvGrid = 40; + { + total_size += + ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( + this_._internal_invgrid(), 2, + this_._impl_._invgrid_cached_byte_size_); + } + // repeated sint32 SpdList = 41; + { + total_size += + ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( + this_._internal_spdlist(), 2, + this_._impl_._spdlist_cached_byte_size_); + } + } + { + // string _pName = 15; + if (!this_._internal__pname().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal__pname()); + } + // sint32 _pmode = 1; + if (this_._internal__pmode() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__pmode()); + } + // sint32 pnum = 2; + if (this_._internal_pnum() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_pnum()); + } + // sint32 plrlevel = 3; + if (this_._internal_plrlevel() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_plrlevel()); + } + // sint32 _px = 4; + if (this_._internal__px() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__px()); + } + // sint32 _py = 5; + if (this_._internal__py() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__py()); + } + // sint32 _pfutx = 6; + if (this_._internal__pfutx() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__pfutx()); + } + // sint32 _pfuty = 7; + if (this_._internal__pfuty() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__pfuty()); + } + // sint32 _pdir = 8; + if (this_._internal__pdir() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__pdir()); + } + // sint32 _pRSpell = 9; + if (this_._internal__prspell() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal__prspell()); + } + // uint32 _pRsplType = 10; + if (this_._internal__prspltype() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal__prspltype()); + } + // uint64 _pMemSpells = 12; + if (this_._internal__pmemspells() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal__pmemspells()); + } + // uint64 _pAblSpells = 13; + if (this_._internal__pablspells() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal__pablspells()); + } + // uint64 _pScrlSpells = 14; + if (this_._internal__pscrlspells() != 0) { + total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( + this_._internal__pscrlspells()); + } + // uint32 _pClass = 16; + if (this_._internal__pclass() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pclass()); + } + // uint32 _pStrength = 17; + if (this_._internal__pstrength() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pstrength()); + } + // uint32 _pBaseStr = 18; + if (this_._internal__pbasestr() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pbasestr()); + } + // uint32 _pMagic = 19; + if (this_._internal__pmagic() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pmagic()); + } + // uint32 _pBaseMag = 20; + if (this_._internal__pbasemag() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pbasemag()); + } + // uint32 _pDexterity = 21; + if (this_._internal__pdexterity() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pdexterity()); + } + // uint32 _pBaseDex = 22; + if (this_._internal__pbasedex() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pbasedex()); + } + // uint32 _pVitality = 23; + if (this_._internal__pvitality() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pvitality()); + } + // uint32 _pBaseVit = 24; + if (this_._internal__pbasevit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pbasevit()); + } + // uint32 _pStatPts = 25; + if (this_._internal__pstatpts() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pstatpts()); + } + // uint32 _pDamageMod = 26; + if (this_._internal__pdamagemod() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pdamagemod()); + } + // uint32 _pHitPoints = 27; + if (this_._internal__phitpoints() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__phitpoints()); + } + // uint32 _pMaxHP = 28; + if (this_._internal__pmaxhp() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pmaxhp()); + } + // sint32 _pMana = 29; + if (this_._internal__pmana() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal__pmana()); + } + // uint32 _pMaxMana = 30; + if (this_._internal__pmaxmana() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pmaxmana()); + } + // uint32 _pLevel = 31; + if (this_._internal__plevel() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__plevel()); + } + // uint32 _pExperience = 32; + if (this_._internal__pexperience() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pexperience()); + } + // uint32 _pArmorClass = 33; + if (this_._internal__parmorclass() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__parmorclass()); + } + // uint32 _pMagResist = 34; + if (this_._internal__pmagresist() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pmagresist()); + } + // uint32 _pFireResist = 35; + if (this_._internal__pfireresist() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pfireresist()); + } + // uint32 _pLightResist = 36; + if (this_._internal__plightresist() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__plightresist()); + } + // uint32 _pGold = 37; + if (this_._internal__pgold() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pgold()); + } + // sint32 HoldItem = 42; + if (this_._internal_holditem() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( + this_._internal_holditem()); + } + // uint32 _pIAC = 43; + if (this_._internal__piac() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__piac()); + } + // uint32 _pIMinDam = 44; + if (this_._internal__pimindam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pimindam()); + } + // uint32 _pIMaxDam = 45; + if (this_._internal__pimaxdam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pimaxdam()); + } + // uint32 _pIBonusDam = 46; + if (this_._internal__pibonusdam() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pibonusdam()); + } + // uint32 _pIBonusToHit = 47; + if (this_._internal__pibonustohit() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pibonustohit()); + } + // uint32 _pIBonusAC = 48; + if (this_._internal__pibonusac() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pibonusac()); + } + // uint32 _pIBonusDamMod = 49; + if (this_._internal__pibonusdammod() != 0) { + total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( + this_._internal__pibonusdammod()); + } + // bool pManaShield = 50; + if (this_._internal_pmanashield() != 0) { + total_size += 3; + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void PlayerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.PlayerData) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable__pspllvl()->MergeFrom(from._internal__pspllvl()); + _this->_internal_mutable_invbody()->MergeFrom(from._internal_invbody()); + _this->_internal_mutable_invlist()->MergeFrom(from._internal_invlist()); + _this->_internal_mutable_invgrid()->MergeFrom(from._internal_invgrid()); + _this->_internal_mutable_spdlist()->MergeFrom(from._internal_spdlist()); + if (!from._internal__pname().empty()) { + _this->_internal_set__pname(from._internal__pname()); + } + if (from._internal__pmode() != 0) { + _this->_impl_._pmode_ = from._impl_._pmode_; + } + if (from._internal_pnum() != 0) { + _this->_impl_.pnum_ = from._impl_.pnum_; + } + if (from._internal_plrlevel() != 0) { + _this->_impl_.plrlevel_ = from._impl_.plrlevel_; + } + if (from._internal__px() != 0) { + _this->_impl_._px_ = from._impl_._px_; + } + if (from._internal__py() != 0) { + _this->_impl_._py_ = from._impl_._py_; + } + if (from._internal__pfutx() != 0) { + _this->_impl_._pfutx_ = from._impl_._pfutx_; + } + if (from._internal__pfuty() != 0) { + _this->_impl_._pfuty_ = from._impl_._pfuty_; + } + if (from._internal__pdir() != 0) { + _this->_impl_._pdir_ = from._impl_._pdir_; + } + if (from._internal__prspell() != 0) { + _this->_impl_._prspell_ = from._impl_._prspell_; + } + if (from._internal__prspltype() != 0) { + _this->_impl_._prspltype_ = from._impl_._prspltype_; + } + if (from._internal__pmemspells() != 0) { + _this->_impl_._pmemspells_ = from._impl_._pmemspells_; + } + if (from._internal__pablspells() != 0) { + _this->_impl_._pablspells_ = from._impl_._pablspells_; + } + if (from._internal__pscrlspells() != 0) { + _this->_impl_._pscrlspells_ = from._impl_._pscrlspells_; + } + if (from._internal__pclass() != 0) { + _this->_impl_._pclass_ = from._impl_._pclass_; + } + if (from._internal__pstrength() != 0) { + _this->_impl_._pstrength_ = from._impl_._pstrength_; + } + if (from._internal__pbasestr() != 0) { + _this->_impl_._pbasestr_ = from._impl_._pbasestr_; + } + if (from._internal__pmagic() != 0) { + _this->_impl_._pmagic_ = from._impl_._pmagic_; + } + if (from._internal__pbasemag() != 0) { + _this->_impl_._pbasemag_ = from._impl_._pbasemag_; + } + if (from._internal__pdexterity() != 0) { + _this->_impl_._pdexterity_ = from._impl_._pdexterity_; + } + if (from._internal__pbasedex() != 0) { + _this->_impl_._pbasedex_ = from._impl_._pbasedex_; + } + if (from._internal__pvitality() != 0) { + _this->_impl_._pvitality_ = from._impl_._pvitality_; + } + if (from._internal__pbasevit() != 0) { + _this->_impl_._pbasevit_ = from._impl_._pbasevit_; + } + if (from._internal__pstatpts() != 0) { + _this->_impl_._pstatpts_ = from._impl_._pstatpts_; + } + if (from._internal__pdamagemod() != 0) { + _this->_impl_._pdamagemod_ = from._impl_._pdamagemod_; + } + if (from._internal__phitpoints() != 0) { + _this->_impl_._phitpoints_ = from._impl_._phitpoints_; + } + if (from._internal__pmaxhp() != 0) { + _this->_impl_._pmaxhp_ = from._impl_._pmaxhp_; + } + if (from._internal__pmana() != 0) { + _this->_impl_._pmana_ = from._impl_._pmana_; + } + if (from._internal__pmaxmana() != 0) { + _this->_impl_._pmaxmana_ = from._impl_._pmaxmana_; + } + if (from._internal__plevel() != 0) { + _this->_impl_._plevel_ = from._impl_._plevel_; + } + if (from._internal__pexperience() != 0) { + _this->_impl_._pexperience_ = from._impl_._pexperience_; + } + if (from._internal__parmorclass() != 0) { + _this->_impl_._parmorclass_ = from._impl_._parmorclass_; + } + if (from._internal__pmagresist() != 0) { + _this->_impl_._pmagresist_ = from._impl_._pmagresist_; + } + if (from._internal__pfireresist() != 0) { + _this->_impl_._pfireresist_ = from._impl_._pfireresist_; + } + if (from._internal__plightresist() != 0) { + _this->_impl_._plightresist_ = from._impl_._plightresist_; + } + if (from._internal__pgold() != 0) { + _this->_impl_._pgold_ = from._impl_._pgold_; + } + if (from._internal_holditem() != 0) { + _this->_impl_.holditem_ = from._impl_.holditem_; + } + if (from._internal__piac() != 0) { + _this->_impl_._piac_ = from._impl_._piac_; + } + if (from._internal__pimindam() != 0) { + _this->_impl_._pimindam_ = from._impl_._pimindam_; + } + if (from._internal__pimaxdam() != 0) { + _this->_impl_._pimaxdam_ = from._impl_._pimaxdam_; + } + if (from._internal__pibonusdam() != 0) { + _this->_impl_._pibonusdam_ = from._impl_._pibonusdam_; + } + if (from._internal__pibonustohit() != 0) { + _this->_impl_._pibonustohit_ = from._impl_._pibonustohit_; + } + if (from._internal__pibonusac() != 0) { + _this->_impl_._pibonusac_ = from._impl_._pibonusac_; + } + if (from._internal__pibonusdammod() != 0) { + _this->_impl_._pibonusdammod_ = from._impl_._pibonusdammod_; + } + if (from._internal_pmanashield() != 0) { + _this->_impl_.pmanashield_ = from._impl_.pmanashield_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void PlayerData::CopyFrom(const PlayerData& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.PlayerData) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void PlayerData::InternalSwap(PlayerData* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_._pspllvl_.InternalSwap(&other->_impl_._pspllvl_); + _impl_.invbody_.InternalSwap(&other->_impl_.invbody_); + _impl_.invlist_.InternalSwap(&other->_impl_.invlist_); + _impl_.invgrid_.InternalSwap(&other->_impl_.invgrid_); + _impl_.spdlist_.InternalSwap(&other->_impl_.spdlist_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._pname_, &other->_impl_._pname_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pmanashield_) + + sizeof(PlayerData::_impl_.pmanashield_) + - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_)>( + reinterpret_cast(&_impl_._pmode_), + reinterpret_cast(&other->_impl_._pmode_)); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace data +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/data.pb.h b/Source/dapi/Backend/Messages/generated/data.pb.h new file mode 100644 index 000000000..edeacb97c --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/data.pb.h @@ -0,0 +1,6992 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: data.proto +// Protobuf C++ Version: 5.29.3 + +#ifndef data_2eproto_2epb_2eh +#define data_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029003 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_data_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_data_2eproto { + static const ::uint32_t offsets[]; +}; +namespace dapi { +namespace data { +class ItemData; +struct ItemDataDefaultTypeInternal; +extern ItemDataDefaultTypeInternal _ItemData_default_instance_; +class MissileData; +struct MissileDataDefaultTypeInternal; +extern MissileDataDefaultTypeInternal _MissileData_default_instance_; +class MonsterData; +struct MonsterDataDefaultTypeInternal; +extern MonsterDataDefaultTypeInternal _MonsterData_default_instance_; +class ObjectData; +struct ObjectDataDefaultTypeInternal; +extern ObjectDataDefaultTypeInternal _ObjectData_default_instance_; +class PlayerData; +struct PlayerDataDefaultTypeInternal; +extern PlayerDataDefaultTypeInternal _PlayerData_default_instance_; +class PortalData; +struct PortalDataDefaultTypeInternal; +extern PortalDataDefaultTypeInternal _PortalData_default_instance_; +class QuestData; +struct QuestDataDefaultTypeInternal; +extern QuestDataDefaultTypeInternal _QuestData_default_instance_; +class TileData; +struct TileDataDefaultTypeInternal; +extern TileDataDefaultTypeInternal _TileData_default_instance_; +class TownerData; +struct TownerDataDefaultTypeInternal; +extern TownerDataDefaultTypeInternal _TownerData_default_instance_; +class TriggerData; +struct TriggerDataDefaultTypeInternal; +extern TriggerDataDefaultTypeInternal _TriggerData_default_instance_; +} // namespace data +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace dapi { +namespace data { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class TriggerData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.TriggerData) */ { + public: + inline TriggerData() : TriggerData(nullptr) {} + ~TriggerData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TriggerData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TriggerData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR TriggerData( + ::google::protobuf::internal::ConstantInitialized); + + inline TriggerData(const TriggerData& from) : TriggerData(nullptr, from) {} + inline TriggerData(TriggerData&& from) noexcept + : TriggerData(nullptr, std::move(from)) {} + inline TriggerData& operator=(const TriggerData& from) { + CopyFrom(from); + return *this; + } + inline TriggerData& operator=(TriggerData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TriggerData& default_instance() { + return *internal_default_instance(); + } + static inline const TriggerData* internal_default_instance() { + return reinterpret_cast( + &_TriggerData_default_instance_); + } + static constexpr int kIndexInFileMessages = 5; + friend void swap(TriggerData& a, TriggerData& b) { a.Swap(&b); } + inline void Swap(TriggerData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TriggerData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TriggerData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const TriggerData& from); + void MergeFrom(const TriggerData& from) { TriggerData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(TriggerData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.TriggerData"; } + + protected: + explicit TriggerData(::google::protobuf::Arena* arena); + TriggerData(::google::protobuf::Arena* arena, const TriggerData& from); + TriggerData(::google::protobuf::Arena* arena, TriggerData&& from) noexcept + : TriggerData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kLvlFieldNumber = 1, + kXFieldNumber = 2, + kYFieldNumber = 3, + kTypeFieldNumber = 4, + }; + // uint32 lvl = 1; + void clear_lvl() ; + ::uint32_t lvl() const; + void set_lvl(::uint32_t value); + + private: + ::uint32_t _internal_lvl() const; + void _internal_set_lvl(::uint32_t value); + + public: + // sint32 x = 2; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // sint32 y = 3; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // sint32 type = 4; + void clear_type() ; + ::int32_t type() const; + void set_type(::int32_t value); + + private: + ::int32_t _internal_type() const; + void _internal_set_type(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.TriggerData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 4, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const TriggerData& from_msg); + ::uint32_t lvl_; + ::int32_t x_; + ::int32_t y_; + ::int32_t type_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class TownerData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.TownerData) */ { + public: + inline TownerData() : TownerData(nullptr) {} + ~TownerData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TownerData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TownerData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR TownerData( + ::google::protobuf::internal::ConstantInitialized); + + inline TownerData(const TownerData& from) : TownerData(nullptr, from) {} + inline TownerData(TownerData&& from) noexcept + : TownerData(nullptr, std::move(from)) {} + inline TownerData& operator=(const TownerData& from) { + CopyFrom(from); + return *this; + } + inline TownerData& operator=(TownerData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TownerData& default_instance() { + return *internal_default_instance(); + } + static inline const TownerData* internal_default_instance() { + return reinterpret_cast( + &_TownerData_default_instance_); + } + static constexpr int kIndexInFileMessages = 7; + friend void swap(TownerData& a, TownerData& b) { a.Swap(&b); } + inline void Swap(TownerData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TownerData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TownerData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const TownerData& from); + void MergeFrom(const TownerData& from) { TownerData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(TownerData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.TownerData"; } + + protected: + explicit TownerData(::google::protobuf::Arena* arena); + TownerData(::google::protobuf::Arena* arena, const TownerData& from); + TownerData(::google::protobuf::Arena* arena, TownerData&& from) noexcept + : TownerData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTNameFieldNumber = 5, + kIDFieldNumber = 1, + kTtypeFieldNumber = 2, + kTxFieldNumber = 3, + kTyFieldNumber = 4, + }; + // string _tName = 5; + void clear__tname() ; + const std::string& _tname() const; + template + void set__tname(Arg_&& arg, Args_... args); + std::string* mutable__tname(); + PROTOBUF_NODISCARD std::string* release__tname(); + void set_allocated__tname(std::string* value); + + private: + const std::string& _internal__tname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set__tname( + const std::string& value); + std::string* _internal_mutable__tname(); + + 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 _ttype = 2; + void clear__ttype() ; + ::uint32_t _ttype() const; + void set__ttype(::uint32_t value); + + private: + ::uint32_t _internal__ttype() const; + void _internal_set__ttype(::uint32_t value); + + public: + // sint32 _tx = 3; + void clear__tx() ; + ::int32_t _tx() const; + void set__tx(::int32_t value); + + private: + ::int32_t _internal__tx() const; + void _internal_set__tx(::int32_t value); + + public: + // sint32 _ty = 4; + void clear__ty() ; + ::int32_t _ty() const; + void set__ty(::int32_t value); + + private: + ::int32_t _internal__ty() const; + void _internal_set__ty(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.TownerData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 0, + 35, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const TownerData& from_msg); + ::google::protobuf::internal::ArenaStringPtr _tname_; + ::uint32_t id_; + ::uint32_t _ttype_; + ::int32_t _tx_; + ::int32_t _ty_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class TileData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.TileData) */ { + public: + inline TileData() : TileData(nullptr) {} + ~TileData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(TileData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(TileData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR TileData( + ::google::protobuf::internal::ConstantInitialized); + + inline TileData(const TileData& from) : TileData(nullptr, from) {} + inline TileData(TileData&& from) noexcept + : TileData(nullptr, std::move(from)) {} + inline TileData& operator=(const TileData& from) { + CopyFrom(from); + return *this; + } + inline TileData& operator=(TileData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const TileData& default_instance() { + return *internal_default_instance(); + } + static inline const TileData* internal_default_instance() { + return reinterpret_cast( + &_TileData_default_instance_); + } + static constexpr int kIndexInFileMessages = 6; + friend void swap(TileData& a, TileData& b) { a.Swap(&b); } + inline void Swap(TileData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(TileData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + TileData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const TileData& from); + void MergeFrom(const TileData& from) { TileData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(TileData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.TileData"; } + + protected: + explicit TileData(::google::protobuf::Arena* arena); + TileData(::google::protobuf::Arena* arena, const TileData& from); + TileData(::google::protobuf::Arena* arena, TileData&& from) noexcept + : TileData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTypeFieldNumber = 1, + kXFieldNumber = 3, + kSolidFieldNumber = 2, + kStopMissileFieldNumber = 5, + kYFieldNumber = 4, + }; + // sint32 type = 1; + void clear_type() ; + ::int32_t type() const; + void set_type(::int32_t value); + + private: + ::int32_t _internal_type() const; + void _internal_set_type(::int32_t value); + + public: + // sint32 x = 3; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // bool solid = 2; + void clear_solid() ; + bool solid() const; + void set_solid(bool value); + + private: + bool _internal_solid() const; + void _internal_set_solid(bool value); + + public: + // bool stopMissile = 5; + void clear_stopmissile() ; + bool stopmissile() const; + void set_stopmissile(bool value); + + private: + bool _internal_stopmissile() const; + void _internal_set_stopmissile(bool value); + + public: + // sint32 y = 4; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.TileData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 5, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const TileData& from_msg); + ::int32_t type_; + ::int32_t x_; + bool solid_; + bool stopmissile_; + ::int32_t y_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class QuestData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.QuestData) */ { + public: + inline QuestData() : QuestData(nullptr) {} + ~QuestData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(QuestData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(QuestData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR QuestData( + ::google::protobuf::internal::ConstantInitialized); + + inline QuestData(const QuestData& from) : QuestData(nullptr, from) {} + inline QuestData(QuestData&& from) noexcept + : QuestData(nullptr, std::move(from)) {} + inline QuestData& operator=(const QuestData& from) { + CopyFrom(from); + return *this; + } + inline QuestData& operator=(QuestData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const QuestData& default_instance() { + return *internal_default_instance(); + } + static inline const QuestData* internal_default_instance() { + return reinterpret_cast( + &_QuestData_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(QuestData& a, QuestData& b) { a.Swap(&b); } + inline void Swap(QuestData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(QuestData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + QuestData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const QuestData& from); + void MergeFrom(const QuestData& from) { QuestData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(QuestData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.QuestData"; } + + protected: + explicit QuestData(::google::protobuf::Arena* arena); + QuestData(::google::protobuf::Arena* arena, const QuestData& from); + QuestData(::google::protobuf::Arena* arena, QuestData&& from) noexcept + : QuestData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<20> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kIdFieldNumber = 1, + kStateFieldNumber = 2, + }; + // 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 state = 2; + void clear_state() ; + ::uint32_t state() const; + void set_state(::uint32_t value); + + private: + ::uint32_t _internal_state() const; + void _internal_set_state(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.QuestData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 1, 2, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const QuestData& from_msg); + ::uint32_t id_; + ::uint32_t state_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class PortalData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.PortalData) */ { + public: + inline PortalData() : PortalData(nullptr) {} + ~PortalData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PortalData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PortalData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PortalData( + ::google::protobuf::internal::ConstantInitialized); + + inline PortalData(const PortalData& from) : PortalData(nullptr, from) {} + inline PortalData(PortalData&& from) noexcept + : PortalData(nullptr, std::move(from)) {} + inline PortalData& operator=(const PortalData& from) { + CopyFrom(from); + return *this; + } + inline PortalData& operator=(PortalData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PortalData& default_instance() { + return *internal_default_instance(); + } + static inline const PortalData* internal_default_instance() { + return reinterpret_cast( + &_PortalData_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(PortalData& a, PortalData& b) { a.Swap(&b); } + inline void Swap(PortalData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PortalData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PortalData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const PortalData& from); + void MergeFrom(const PortalData& from) { PortalData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PortalData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.PortalData"; } + + protected: + explicit PortalData(::google::protobuf::Arena* arena); + PortalData(::google::protobuf::Arena* arena, const PortalData& from); + PortalData(::google::protobuf::Arena* arena, PortalData&& from) noexcept + : PortalData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + kPlayerFieldNumber = 3, + }; + // uint32 x = 1; + void clear_x() ; + ::uint32_t x() const; + void set_x(::uint32_t value); + + private: + ::uint32_t _internal_x() const; + void _internal_set_x(::uint32_t value); + + public: + // uint32 y = 2; + void clear_y() ; + ::uint32_t y() const; + void set_y(::uint32_t value); + + private: + ::uint32_t _internal_y() const; + void _internal_set_y(::uint32_t value); + + public: + // uint32 player = 3; + void clear_player() ; + ::uint32_t player() const; + void set_player(::uint32_t value); + + private: + ::uint32_t _internal_player() const; + void _internal_set_player(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.PortalData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 2, 3, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PortalData& from_msg); + ::uint32_t x_; + ::uint32_t y_; + ::uint32_t player_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class PlayerData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.PlayerData) */ { + public: + inline PlayerData() : PlayerData(nullptr) {} + ~PlayerData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(PlayerData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(PlayerData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR PlayerData( + ::google::protobuf::internal::ConstantInitialized); + + inline PlayerData(const PlayerData& from) : PlayerData(nullptr, from) {} + inline PlayerData(PlayerData&& from) noexcept + : PlayerData(nullptr, std::move(from)) {} + inline PlayerData& operator=(const PlayerData& from) { + CopyFrom(from); + return *this; + } + inline PlayerData& operator=(PlayerData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const PlayerData& default_instance() { + return *internal_default_instance(); + } + static inline const PlayerData* internal_default_instance() { + return reinterpret_cast( + &_PlayerData_default_instance_); + } + static constexpr int kIndexInFileMessages = 9; + friend void swap(PlayerData& a, PlayerData& b) { a.Swap(&b); } + inline void Swap(PlayerData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(PlayerData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + PlayerData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const PlayerData& from); + void MergeFrom(const PlayerData& from) { PlayerData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(PlayerData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.PlayerData"; } + + protected: + explicit PlayerData(::google::protobuf::Arena* arena); + PlayerData(::google::protobuf::Arena* arena, const PlayerData& from); + PlayerData(::google::protobuf::Arena* arena, PlayerData&& from) noexcept + : PlayerData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPSplLvlFieldNumber = 11, + kInvBodyFieldNumber = 38, + kInvListFieldNumber = 39, + kInvGridFieldNumber = 40, + kSpdListFieldNumber = 41, + kPNameFieldNumber = 15, + kPmodeFieldNumber = 1, + kPnumFieldNumber = 2, + kPlrlevelFieldNumber = 3, + kPxFieldNumber = 4, + kPyFieldNumber = 5, + kPfutxFieldNumber = 6, + kPfutyFieldNumber = 7, + kPdirFieldNumber = 8, + kPRSpellFieldNumber = 9, + kPRsplTypeFieldNumber = 10, + kPMemSpellsFieldNumber = 12, + kPAblSpellsFieldNumber = 13, + kPScrlSpellsFieldNumber = 14, + kPClassFieldNumber = 16, + kPStrengthFieldNumber = 17, + kPBaseStrFieldNumber = 18, + kPMagicFieldNumber = 19, + kPBaseMagFieldNumber = 20, + kPDexterityFieldNumber = 21, + kPBaseDexFieldNumber = 22, + kPVitalityFieldNumber = 23, + kPBaseVitFieldNumber = 24, + kPStatPtsFieldNumber = 25, + kPDamageModFieldNumber = 26, + kPHitPointsFieldNumber = 27, + kPMaxHPFieldNumber = 28, + kPManaFieldNumber = 29, + kPMaxManaFieldNumber = 30, + kPLevelFieldNumber = 31, + kPExperienceFieldNumber = 32, + kPArmorClassFieldNumber = 33, + kPMagResistFieldNumber = 34, + kPFireResistFieldNumber = 35, + kPLightResistFieldNumber = 36, + kPGoldFieldNumber = 37, + kHoldItemFieldNumber = 42, + kPIACFieldNumber = 43, + kPIMinDamFieldNumber = 44, + kPIMaxDamFieldNumber = 45, + kPIBonusDamFieldNumber = 46, + kPIBonusToHitFieldNumber = 47, + kPIBonusACFieldNumber = 48, + kPIBonusDamModFieldNumber = 49, + kPManaShieldFieldNumber = 50, + }; + // repeated uint32 _pSplLvl = 11; + int _pspllvl_size() const; + private: + int _internal__pspllvl_size() const; + + public: + void clear__pspllvl() ; + ::uint32_t _pspllvl(int index) const; + void set__pspllvl(int index, ::uint32_t value); + void add__pspllvl(::uint32_t value); + const ::google::protobuf::RepeatedField<::uint32_t>& _pspllvl() const; + ::google::protobuf::RepeatedField<::uint32_t>* mutable__pspllvl(); + + private: + const ::google::protobuf::RepeatedField<::uint32_t>& _internal__pspllvl() const; + ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable__pspllvl(); + + public: + // repeated sint32 InvBody = 38; + int invbody_size() const; + private: + int _internal_invbody_size() const; + + public: + void clear_invbody() ; + ::int32_t invbody(int index) const; + void set_invbody(int index, ::int32_t value); + void add_invbody(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& invbody() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_invbody(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_invbody() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invbody(); + + public: + // repeated sint32 InvList = 39; + int invlist_size() const; + private: + int _internal_invlist_size() const; + + public: + void clear_invlist() ; + ::int32_t invlist(int index) const; + void set_invlist(int index, ::int32_t value); + void add_invlist(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& invlist() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_invlist(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_invlist() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invlist(); + + public: + // repeated sint32 InvGrid = 40; + int invgrid_size() const; + private: + int _internal_invgrid_size() const; + + public: + void clear_invgrid() ; + ::int32_t invgrid(int index) const; + void set_invgrid(int index, ::int32_t value); + void add_invgrid(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& invgrid() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_invgrid(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_invgrid() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invgrid(); + + public: + // repeated sint32 SpdList = 41; + int spdlist_size() const; + private: + int _internal_spdlist_size() const; + + public: + void clear_spdlist() ; + ::int32_t spdlist(int index) const; + void set_spdlist(int index, ::int32_t value); + void add_spdlist(::int32_t value); + const ::google::protobuf::RepeatedField<::int32_t>& spdlist() const; + ::google::protobuf::RepeatedField<::int32_t>* mutable_spdlist(); + + private: + const ::google::protobuf::RepeatedField<::int32_t>& _internal_spdlist() const; + ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_spdlist(); + + public: + // string _pName = 15; + void clear__pname() ; + const std::string& _pname() const; + template + void set__pname(Arg_&& arg, Args_... args); + std::string* mutable__pname(); + PROTOBUF_NODISCARD std::string* release__pname(); + void set_allocated__pname(std::string* value); + + private: + const std::string& _internal__pname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set__pname( + const std::string& value); + std::string* _internal_mutable__pname(); + + public: + // sint32 _pmode = 1; + void clear__pmode() ; + ::int32_t _pmode() const; + void set__pmode(::int32_t value); + + private: + ::int32_t _internal__pmode() const; + void _internal_set__pmode(::int32_t value); + + public: + // sint32 pnum = 2; + void clear_pnum() ; + ::int32_t pnum() const; + void set_pnum(::int32_t value); + + private: + ::int32_t _internal_pnum() const; + void _internal_set_pnum(::int32_t value); + + public: + // sint32 plrlevel = 3; + void clear_plrlevel() ; + ::int32_t plrlevel() const; + void set_plrlevel(::int32_t value); + + private: + ::int32_t _internal_plrlevel() const; + void _internal_set_plrlevel(::int32_t value); + + public: + // sint32 _px = 4; + void clear__px() ; + ::int32_t _px() const; + void set__px(::int32_t value); + + private: + ::int32_t _internal__px() const; + void _internal_set__px(::int32_t value); + + public: + // sint32 _py = 5; + void clear__py() ; + ::int32_t _py() const; + void set__py(::int32_t value); + + private: + ::int32_t _internal__py() const; + void _internal_set__py(::int32_t value); + + public: + // sint32 _pfutx = 6; + void clear__pfutx() ; + ::int32_t _pfutx() const; + void set__pfutx(::int32_t value); + + private: + ::int32_t _internal__pfutx() const; + void _internal_set__pfutx(::int32_t value); + + public: + // sint32 _pfuty = 7; + void clear__pfuty() ; + ::int32_t _pfuty() const; + void set__pfuty(::int32_t value); + + private: + ::int32_t _internal__pfuty() const; + void _internal_set__pfuty(::int32_t value); + + public: + // sint32 _pdir = 8; + void clear__pdir() ; + ::int32_t _pdir() const; + void set__pdir(::int32_t value); + + private: + ::int32_t _internal__pdir() const; + void _internal_set__pdir(::int32_t value); + + public: + // sint32 _pRSpell = 9; + void clear__prspell() ; + ::int32_t _prspell() const; + void set__prspell(::int32_t value); + + private: + ::int32_t _internal__prspell() const; + void _internal_set__prspell(::int32_t value); + + public: + // uint32 _pRsplType = 10; + void clear__prspltype() ; + ::uint32_t _prspltype() const; + void set__prspltype(::uint32_t value); + + private: + ::uint32_t _internal__prspltype() const; + void _internal_set__prspltype(::uint32_t value); + + public: + // uint64 _pMemSpells = 12; + void clear__pmemspells() ; + ::uint64_t _pmemspells() const; + void set__pmemspells(::uint64_t value); + + private: + ::uint64_t _internal__pmemspells() const; + void _internal_set__pmemspells(::uint64_t value); + + public: + // uint64 _pAblSpells = 13; + void clear__pablspells() ; + ::uint64_t _pablspells() const; + void set__pablspells(::uint64_t value); + + private: + ::uint64_t _internal__pablspells() const; + void _internal_set__pablspells(::uint64_t value); + + public: + // uint64 _pScrlSpells = 14; + void clear__pscrlspells() ; + ::uint64_t _pscrlspells() const; + void set__pscrlspells(::uint64_t value); + + private: + ::uint64_t _internal__pscrlspells() const; + void _internal_set__pscrlspells(::uint64_t value); + + public: + // uint32 _pClass = 16; + void clear__pclass() ; + ::uint32_t _pclass() const; + void set__pclass(::uint32_t value); + + private: + ::uint32_t _internal__pclass() const; + void _internal_set__pclass(::uint32_t value); + + public: + // uint32 _pStrength = 17; + void clear__pstrength() ; + ::uint32_t _pstrength() const; + void set__pstrength(::uint32_t value); + + private: + ::uint32_t _internal__pstrength() const; + void _internal_set__pstrength(::uint32_t value); + + public: + // uint32 _pBaseStr = 18; + void clear__pbasestr() ; + ::uint32_t _pbasestr() const; + void set__pbasestr(::uint32_t value); + + private: + ::uint32_t _internal__pbasestr() const; + void _internal_set__pbasestr(::uint32_t value); + + public: + // uint32 _pMagic = 19; + void clear__pmagic() ; + ::uint32_t _pmagic() const; + void set__pmagic(::uint32_t value); + + private: + ::uint32_t _internal__pmagic() const; + void _internal_set__pmagic(::uint32_t value); + + public: + // uint32 _pBaseMag = 20; + void clear__pbasemag() ; + ::uint32_t _pbasemag() const; + void set__pbasemag(::uint32_t value); + + private: + ::uint32_t _internal__pbasemag() const; + void _internal_set__pbasemag(::uint32_t value); + + public: + // uint32 _pDexterity = 21; + void clear__pdexterity() ; + ::uint32_t _pdexterity() const; + void set__pdexterity(::uint32_t value); + + private: + ::uint32_t _internal__pdexterity() const; + void _internal_set__pdexterity(::uint32_t value); + + public: + // uint32 _pBaseDex = 22; + void clear__pbasedex() ; + ::uint32_t _pbasedex() const; + void set__pbasedex(::uint32_t value); + + private: + ::uint32_t _internal__pbasedex() const; + void _internal_set__pbasedex(::uint32_t value); + + public: + // uint32 _pVitality = 23; + void clear__pvitality() ; + ::uint32_t _pvitality() const; + void set__pvitality(::uint32_t value); + + private: + ::uint32_t _internal__pvitality() const; + void _internal_set__pvitality(::uint32_t value); + + public: + // uint32 _pBaseVit = 24; + void clear__pbasevit() ; + ::uint32_t _pbasevit() const; + void set__pbasevit(::uint32_t value); + + private: + ::uint32_t _internal__pbasevit() const; + void _internal_set__pbasevit(::uint32_t value); + + public: + // uint32 _pStatPts = 25; + void clear__pstatpts() ; + ::uint32_t _pstatpts() const; + void set__pstatpts(::uint32_t value); + + private: + ::uint32_t _internal__pstatpts() const; + void _internal_set__pstatpts(::uint32_t value); + + public: + // uint32 _pDamageMod = 26; + void clear__pdamagemod() ; + ::uint32_t _pdamagemod() const; + void set__pdamagemod(::uint32_t value); + + private: + ::uint32_t _internal__pdamagemod() const; + void _internal_set__pdamagemod(::uint32_t value); + + public: + // uint32 _pHitPoints = 27; + void clear__phitpoints() ; + ::uint32_t _phitpoints() const; + void set__phitpoints(::uint32_t value); + + private: + ::uint32_t _internal__phitpoints() const; + void _internal_set__phitpoints(::uint32_t value); + + public: + // uint32 _pMaxHP = 28; + void clear__pmaxhp() ; + ::uint32_t _pmaxhp() const; + void set__pmaxhp(::uint32_t value); + + private: + ::uint32_t _internal__pmaxhp() const; + void _internal_set__pmaxhp(::uint32_t value); + + public: + // sint32 _pMana = 29; + void clear__pmana() ; + ::int32_t _pmana() const; + void set__pmana(::int32_t value); + + private: + ::int32_t _internal__pmana() const; + void _internal_set__pmana(::int32_t value); + + public: + // uint32 _pMaxMana = 30; + void clear__pmaxmana() ; + ::uint32_t _pmaxmana() const; + void set__pmaxmana(::uint32_t value); + + private: + ::uint32_t _internal__pmaxmana() const; + void _internal_set__pmaxmana(::uint32_t value); + + public: + // uint32 _pLevel = 31; + void clear__plevel() ; + ::uint32_t _plevel() const; + void set__plevel(::uint32_t value); + + private: + ::uint32_t _internal__plevel() const; + void _internal_set__plevel(::uint32_t value); + + public: + // uint32 _pExperience = 32; + void clear__pexperience() ; + ::uint32_t _pexperience() const; + void set__pexperience(::uint32_t value); + + private: + ::uint32_t _internal__pexperience() const; + void _internal_set__pexperience(::uint32_t value); + + public: + // uint32 _pArmorClass = 33; + void clear__parmorclass() ; + ::uint32_t _parmorclass() const; + void set__parmorclass(::uint32_t value); + + private: + ::uint32_t _internal__parmorclass() const; + void _internal_set__parmorclass(::uint32_t value); + + public: + // uint32 _pMagResist = 34; + void clear__pmagresist() ; + ::uint32_t _pmagresist() const; + void set__pmagresist(::uint32_t value); + + private: + ::uint32_t _internal__pmagresist() const; + void _internal_set__pmagresist(::uint32_t value); + + public: + // uint32 _pFireResist = 35; + void clear__pfireresist() ; + ::uint32_t _pfireresist() const; + void set__pfireresist(::uint32_t value); + + private: + ::uint32_t _internal__pfireresist() const; + void _internal_set__pfireresist(::uint32_t value); + + public: + // uint32 _pLightResist = 36; + void clear__plightresist() ; + ::uint32_t _plightresist() const; + void set__plightresist(::uint32_t value); + + private: + ::uint32_t _internal__plightresist() const; + void _internal_set__plightresist(::uint32_t value); + + public: + // uint32 _pGold = 37; + void clear__pgold() ; + ::uint32_t _pgold() const; + void set__pgold(::uint32_t value); + + private: + ::uint32_t _internal__pgold() const; + void _internal_set__pgold(::uint32_t value); + + public: + // sint32 HoldItem = 42; + void clear_holditem() ; + ::int32_t holditem() const; + void set_holditem(::int32_t value); + + private: + ::int32_t _internal_holditem() const; + void _internal_set_holditem(::int32_t value); + + public: + // uint32 _pIAC = 43; + void clear__piac() ; + ::uint32_t _piac() const; + void set__piac(::uint32_t value); + + private: + ::uint32_t _internal__piac() const; + void _internal_set__piac(::uint32_t value); + + public: + // uint32 _pIMinDam = 44; + void clear__pimindam() ; + ::uint32_t _pimindam() const; + void set__pimindam(::uint32_t value); + + private: + ::uint32_t _internal__pimindam() const; + void _internal_set__pimindam(::uint32_t value); + + public: + // uint32 _pIMaxDam = 45; + void clear__pimaxdam() ; + ::uint32_t _pimaxdam() const; + void set__pimaxdam(::uint32_t value); + + private: + ::uint32_t _internal__pimaxdam() const; + void _internal_set__pimaxdam(::uint32_t value); + + public: + // uint32 _pIBonusDam = 46; + void clear__pibonusdam() ; + ::uint32_t _pibonusdam() const; + void set__pibonusdam(::uint32_t value); + + private: + ::uint32_t _internal__pibonusdam() const; + void _internal_set__pibonusdam(::uint32_t value); + + public: + // uint32 _pIBonusToHit = 47; + void clear__pibonustohit() ; + ::uint32_t _pibonustohit() const; + void set__pibonustohit(::uint32_t value); + + private: + ::uint32_t _internal__pibonustohit() const; + void _internal_set__pibonustohit(::uint32_t value); + + public: + // uint32 _pIBonusAC = 48; + void clear__pibonusac() ; + ::uint32_t _pibonusac() const; + void set__pibonusac(::uint32_t value); + + private: + ::uint32_t _internal__pibonusac() const; + void _internal_set__pibonusac(::uint32_t value); + + public: + // uint32 _pIBonusDamMod = 49; + void clear__pibonusdammod() ; + ::uint32_t _pibonusdammod() const; + void set__pibonusdammod(::uint32_t value); + + private: + ::uint32_t _internal__pibonusdammod() const; + void _internal_set__pibonusdammod(::uint32_t value); + + public: + // bool pManaShield = 50; + void clear_pmanashield() ; + bool pmanashield() const; + void set_pmanashield(bool value); + + private: + bool _internal_pmanashield() const; + void _internal_set_pmanashield(bool value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.PlayerData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 50, 0, + 83, 9> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const PlayerData& from_msg); + ::google::protobuf::RepeatedField<::uint32_t> _pspllvl_; + ::google::protobuf::internal::CachedSize __pspllvl_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> invbody_; + ::google::protobuf::internal::CachedSize _invbody_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> invlist_; + ::google::protobuf::internal::CachedSize _invlist_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> invgrid_; + ::google::protobuf::internal::CachedSize _invgrid_cached_byte_size_; + ::google::protobuf::RepeatedField<::int32_t> spdlist_; + ::google::protobuf::internal::CachedSize _spdlist_cached_byte_size_; + ::google::protobuf::internal::ArenaStringPtr _pname_; + ::int32_t _pmode_; + ::int32_t pnum_; + ::int32_t plrlevel_; + ::int32_t _px_; + ::int32_t _py_; + ::int32_t _pfutx_; + ::int32_t _pfuty_; + ::int32_t _pdir_; + ::int32_t _prspell_; + ::uint32_t _prspltype_; + ::uint64_t _pmemspells_; + ::uint64_t _pablspells_; + ::uint64_t _pscrlspells_; + ::uint32_t _pclass_; + ::uint32_t _pstrength_; + ::uint32_t _pbasestr_; + ::uint32_t _pmagic_; + ::uint32_t _pbasemag_; + ::uint32_t _pdexterity_; + ::uint32_t _pbasedex_; + ::uint32_t _pvitality_; + ::uint32_t _pbasevit_; + ::uint32_t _pstatpts_; + ::uint32_t _pdamagemod_; + ::uint32_t _phitpoints_; + ::uint32_t _pmaxhp_; + ::int32_t _pmana_; + ::uint32_t _pmaxmana_; + ::uint32_t _plevel_; + ::uint32_t _pexperience_; + ::uint32_t _parmorclass_; + ::uint32_t _pmagresist_; + ::uint32_t _pfireresist_; + ::uint32_t _plightresist_; + ::uint32_t _pgold_; + ::int32_t holditem_; + ::uint32_t _piac_; + ::uint32_t _pimindam_; + ::uint32_t _pimaxdam_; + ::uint32_t _pibonusdam_; + ::uint32_t _pibonustohit_; + ::uint32_t _pibonusac_; + ::uint32_t _pibonusdammod_; + bool pmanashield_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class ObjectData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.ObjectData) */ { + public: + inline ObjectData() : ObjectData(nullptr) {} + ~ObjectData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ObjectData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ObjectData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ObjectData( + ::google::protobuf::internal::ConstantInitialized); + + inline ObjectData(const ObjectData& from) : ObjectData(nullptr, from) {} + inline ObjectData(ObjectData&& from) noexcept + : ObjectData(nullptr, std::move(from)) {} + inline ObjectData& operator=(const ObjectData& from) { + CopyFrom(from); + return *this; + } + inline ObjectData& operator=(ObjectData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ObjectData& default_instance() { + return *internal_default_instance(); + } + static inline const ObjectData* internal_default_instance() { + return reinterpret_cast( + &_ObjectData_default_instance_); + } + static constexpr int kIndexInFileMessages = 3; + friend void swap(ObjectData& a, ObjectData& b) { a.Swap(&b); } + inline void Swap(ObjectData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ObjectData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ObjectData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ObjectData& from); + void MergeFrom(const ObjectData& from) { ObjectData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ObjectData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.ObjectData"; } + + protected: + explicit ObjectData(::google::protobuf::Arena* arena); + ObjectData(::google::protobuf::Arena* arena, const ObjectData& from); + ObjectData(::google::protobuf::Arena* arena, ObjectData&& from) noexcept + : ObjectData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kXFieldNumber = 1, + kYFieldNumber = 2, + kTypeFieldNumber = 3, + kShrineTypeFieldNumber = 4, + kDoorStateFieldNumber = 6, + kSolidFieldNumber = 5, + kSelectableFieldNumber = 7, + kTrappedFieldNumber = 9, + kIndexFieldNumber = 8, + }; + // uint32 x = 1; + void clear_x() ; + ::uint32_t x() const; + void set_x(::uint32_t value); + + private: + ::uint32_t _internal_x() const; + void _internal_set_x(::uint32_t value); + + public: + // uint32 y = 2; + void clear_y() ; + ::uint32_t y() const; + void set_y(::uint32_t value); + + private: + ::uint32_t _internal_y() const; + void _internal_set_y(::uint32_t value); + + public: + // sint32 type = 3; + void clear_type() ; + ::int32_t type() const; + void set_type(::int32_t value); + + private: + ::int32_t _internal_type() const; + void _internal_set_type(::int32_t value); + + public: + // sint32 shrineType = 4; + void clear_shrinetype() ; + ::int32_t shrinetype() const; + void set_shrinetype(::int32_t value); + + private: + ::int32_t _internal_shrinetype() const; + void _internal_set_shrinetype(::int32_t value); + + public: + // sint32 doorState = 6; + void clear_doorstate() ; + ::int32_t doorstate() const; + void set_doorstate(::int32_t value); + + private: + ::int32_t _internal_doorstate() const; + void _internal_set_doorstate(::int32_t value); + + public: + // bool solid = 5; + void clear_solid() ; + bool solid() const; + void set_solid(bool value); + + private: + bool _internal_solid() const; + void _internal_set_solid(bool value); + + public: + // bool selectable = 7; + void clear_selectable() ; + bool selectable() const; + void set_selectable(bool value); + + private: + bool _internal_selectable() const; + void _internal_set_selectable(bool value); + + public: + // bool trapped = 9; + void clear_trapped() ; + bool trapped() const; + void set_trapped(bool value); + + private: + bool _internal_trapped() const; + void _internal_set_trapped(bool value); + + public: + // uint32 index = 8; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.ObjectData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 9, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ObjectData& from_msg); + ::uint32_t x_; + ::uint32_t y_; + ::int32_t type_; + ::int32_t shrinetype_; + ::int32_t doorstate_; + bool solid_; + bool selectable_; + bool trapped_; + ::uint32_t index_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class MonsterData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.MonsterData) */ { + public: + inline MonsterData() : MonsterData(nullptr) {} + ~MonsterData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(MonsterData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(MonsterData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR MonsterData( + ::google::protobuf::internal::ConstantInitialized); + + inline MonsterData(const MonsterData& from) : MonsterData(nullptr, from) {} + inline MonsterData(MonsterData&& from) noexcept + : MonsterData(nullptr, std::move(from)) {} + inline MonsterData& operator=(const MonsterData& from) { + CopyFrom(from); + return *this; + } + inline MonsterData& operator=(MonsterData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const MonsterData& default_instance() { + return *internal_default_instance(); + } + static inline const MonsterData* internal_default_instance() { + return reinterpret_cast( + &_MonsterData_default_instance_); + } + static constexpr int kIndexInFileMessages = 4; + friend void swap(MonsterData& a, MonsterData& b) { a.Swap(&b); } + inline void Swap(MonsterData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MonsterData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MonsterData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const MonsterData& from); + void MergeFrom(const MonsterData& from) { MonsterData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(MonsterData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.MonsterData"; } + + protected: + explicit MonsterData(::google::protobuf::Arena* arena); + MonsterData(::google::protobuf::Arena* arena, const MonsterData& from); + MonsterData(::google::protobuf::Arena* arena, MonsterData&& from) noexcept + : MonsterData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kNameFieldNumber = 6, + kIndexFieldNumber = 1, + kXFieldNumber = 2, + kYFieldNumber = 3, + kFutxFieldNumber = 4, + kFutyFieldNumber = 5, + kTypeFieldNumber = 7, + kKillsFieldNumber = 8, + kModeFieldNumber = 9, + kUniqueFieldNumber = 10, + }; + // string name = 6; + void clear_name() ; + const std::string& name() const; + template + void set_name(Arg_&& arg, Args_... args); + std::string* mutable_name(); + PROTOBUF_NODISCARD std::string* release_name(); + void set_allocated_name(std::string* value); + + 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 index = 1; + void clear_index() ; + ::uint32_t index() const; + void set_index(::uint32_t value); + + private: + ::uint32_t _internal_index() const; + void _internal_set_index(::uint32_t value); + + public: + // sint32 x = 2; + void clear_x() ; + ::int32_t x() const; + void set_x(::int32_t value); + + private: + ::int32_t _internal_x() const; + void _internal_set_x(::int32_t value); + + public: + // sint32 y = 3; + void clear_y() ; + ::int32_t y() const; + void set_y(::int32_t value); + + private: + ::int32_t _internal_y() const; + void _internal_set_y(::int32_t value); + + public: + // sint32 futx = 4; + void clear_futx() ; + ::int32_t futx() const; + void set_futx(::int32_t value); + + private: + ::int32_t _internal_futx() const; + void _internal_set_futx(::int32_t value); + + public: + // sint32 futy = 5; + void clear_futy() ; + ::int32_t futy() const; + void set_futy(::int32_t value); + + private: + ::int32_t _internal_futy() const; + void _internal_set_futy(::int32_t value); + + public: + // sint32 type = 7; + void clear_type() ; + ::int32_t type() const; + void set_type(::int32_t value); + + private: + ::int32_t _internal_type() const; + void _internal_set_type(::int32_t value); + + public: + // sint32 kills = 8; + void clear_kills() ; + ::int32_t kills() const; + void set_kills(::int32_t value); + + private: + ::int32_t _internal_kills() const; + void _internal_set_kills(::int32_t value); + + public: + // sint32 mode = 9; + void clear_mode() ; + ::int32_t mode() const; + void set_mode(::int32_t value); + + private: + ::int32_t _internal_mode() const; + void _internal_set_mode(::int32_t value); + + public: + // bool unique = 10; + void clear_unique() ; + bool unique() const; + void set_unique(bool value); + + private: + bool _internal_unique() const; + void _internal_set_unique(bool value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.MonsterData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 4, 10, 0, + 42, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const MonsterData& from_msg); + ::google::protobuf::internal::ArenaStringPtr name_; + ::uint32_t index_; + ::int32_t x_; + ::int32_t y_; + ::int32_t futx_; + ::int32_t futy_; + ::int32_t type_; + ::int32_t kills_; + ::int32_t mode_; + bool unique_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class MissileData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.MissileData) */ { + public: + inline MissileData() : MissileData(nullptr) {} + ~MissileData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(MissileData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(MissileData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR MissileData( + ::google::protobuf::internal::ConstantInitialized); + + inline MissileData(const MissileData& from) : MissileData(nullptr, from) {} + inline MissileData(MissileData&& from) noexcept + : MissileData(nullptr, std::move(from)) {} + inline MissileData& operator=(const MissileData& from) { + CopyFrom(from); + return *this; + } + inline MissileData& operator=(MissileData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const MissileData& default_instance() { + return *internal_default_instance(); + } + static inline const MissileData* internal_default_instance() { + return reinterpret_cast( + &_MissileData_default_instance_); + } + static constexpr int kIndexInFileMessages = 2; + friend void swap(MissileData& a, MissileData& b) { a.Swap(&b); } + inline void Swap(MissileData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(MissileData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + MissileData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const MissileData& from); + void MergeFrom(const MissileData& from) { MissileData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(MissileData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.MissileData"; } + + protected: + explicit MissileData(::google::protobuf::Arena* arena); + MissileData(::google::protobuf::Arena* arena, const MissileData& from); + MissileData(::google::protobuf::Arena* arena, MissileData&& from) noexcept + : MissileData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kTypeFieldNumber = 1, + kXFieldNumber = 2, + kYFieldNumber = 3, + kXvelFieldNumber = 4, + kYvelFieldNumber = 5, + kSxFieldNumber = 6, + kSyFieldNumber = 7, + }; + // sint32 type = 1; + void clear_type() ; + ::int32_t type() const; + void set_type(::int32_t value); + + private: + ::int32_t _internal_type() const; + void _internal_set_type(::int32_t value); + + public: + // uint32 x = 2; + void clear_x() ; + ::uint32_t x() const; + void set_x(::uint32_t value); + + private: + ::uint32_t _internal_x() const; + void _internal_set_x(::uint32_t value); + + public: + // uint32 y = 3; + void clear_y() ; + ::uint32_t y() const; + void set_y(::uint32_t value); + + private: + ::uint32_t _internal_y() const; + void _internal_set_y(::uint32_t value); + + public: + // sint32 xvel = 4; + void clear_xvel() ; + ::int32_t xvel() const; + void set_xvel(::int32_t value); + + private: + ::int32_t _internal_xvel() const; + void _internal_set_xvel(::int32_t value); + + public: + // sint32 yvel = 5; + void clear_yvel() ; + ::int32_t yvel() const; + void set_yvel(::int32_t value); + + private: + ::int32_t _internal_yvel() const; + void _internal_set_yvel(::int32_t value); + + public: + // sint32 sx = 6; + void clear_sx() ; + ::int32_t sx() const; + void set_sx(::int32_t value); + + private: + ::int32_t _internal_sx() const; + void _internal_set_sx(::int32_t value); + + public: + // sint32 sy = 7; + void clear_sy() ; + ::int32_t sy() const; + void set_sy(::int32_t value); + + private: + ::int32_t _internal_sy() const; + void _internal_set_sy(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.MissileData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 3, 7, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const MissileData& from_msg); + ::int32_t type_; + ::uint32_t x_; + ::uint32_t y_; + ::int32_t xvel_; + ::int32_t yvel_; + ::int32_t sx_; + ::int32_t sy_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; +// ------------------------------------------------------------------- + +class ItemData final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.data.ItemData) */ { + public: + inline ItemData() : ItemData(nullptr) {} + ~ItemData() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ItemData* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ItemData)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ItemData( + ::google::protobuf::internal::ConstantInitialized); + + inline ItemData(const ItemData& from) : ItemData(nullptr, from) {} + inline ItemData(ItemData&& from) noexcept + : ItemData(nullptr, std::move(from)) {} + inline ItemData& operator=(const ItemData& from) { + CopyFrom(from); + return *this; + } + inline ItemData& operator=(ItemData&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ItemData& default_instance() { + return *internal_default_instance(); + } + static inline const ItemData* internal_default_instance() { + return reinterpret_cast( + &_ItemData_default_instance_); + } + static constexpr int kIndexInFileMessages = 8; + friend void swap(ItemData& a, ItemData& b) { a.Swap(&b); } + inline void Swap(ItemData* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ItemData* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ItemData* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ItemData& from); + void MergeFrom(const ItemData& from) { ItemData::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ItemData* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.data.ItemData"; } + + protected: + explicit ItemData(::google::protobuf::Arena* arena); + ItemData(::google::protobuf::Arena* arena, const ItemData& from); + ItemData(::google::protobuf::Arena* arena, ItemData&& from) noexcept + : ItemData(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kINameFieldNumber = 7, + kIINameFieldNumber = 8, + kIDFieldNumber = 1, + kItypeFieldNumber = 2, + kIxFieldNumber = 3, + kIyFieldNumber = 4, + kIMagicalFieldNumber = 6, + kIClassFieldNumber = 9, + kICursFieldNumber = 10, + kIValueFieldNumber = 11, + kIMinDamFieldNumber = 12, + kIMaxDamFieldNumber = 13, + kIACFieldNumber = 14, + kIFlagsFieldNumber = 15, + kIMiscIdFieldNumber = 16, + kISpellFieldNumber = 17, + kIChargesFieldNumber = 18, + kIMaxChargesFieldNumber = 19, + kIDurabilityFieldNumber = 20, + kIMaxDurFieldNumber = 21, + kIPLDamFieldNumber = 22, + kIPLToHitFieldNumber = 23, + kIPLACFieldNumber = 24, + kIPLStrFieldNumber = 25, + kIPLMagFieldNumber = 26, + kIIdentifiedFieldNumber = 5, + kIStatFlagFieldNumber = 47, + kIPLDexFieldNumber = 27, + kIPLVitFieldNumber = 28, + kIPLFRFieldNumber = 29, + kIPLLRFieldNumber = 30, + kIPLMRFieldNumber = 31, + kIPLManaFieldNumber = 32, + kIPLHPFieldNumber = 33, + kIPLDamModFieldNumber = 34, + kIPLGetHitFieldNumber = 35, + kIPLLightFieldNumber = 36, + kISplLvlAddFieldNumber = 37, + kIFMinDamFieldNumber = 38, + kIFMaxDamFieldNumber = 39, + kILMinDamFieldNumber = 40, + kILMaxDamFieldNumber = 41, + kIPrePowerFieldNumber = 42, + kISufPowerFieldNumber = 43, + kIMinStrFieldNumber = 44, + kIMinMagFieldNumber = 45, + kIMinDexFieldNumber = 46, + kIDidxFieldNumber = 48, + }; + // string _iName = 7; + void clear__iname() ; + const std::string& _iname() const; + template + void set__iname(Arg_&& arg, Args_... args); + std::string* mutable__iname(); + PROTOBUF_NODISCARD std::string* release__iname(); + void set_allocated__iname(std::string* value); + + private: + const std::string& _internal__iname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set__iname( + const std::string& value); + std::string* _internal_mutable__iname(); + + public: + // string _iIName = 8; + void clear__iiname() ; + const std::string& _iiname() const; + template + void set__iiname(Arg_&& arg, Args_... args); + std::string* mutable__iiname(); + PROTOBUF_NODISCARD std::string* release__iiname(); + void set_allocated__iiname(std::string* value); + + private: + const std::string& _internal__iiname() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set__iiname( + const std::string& value); + std::string* _internal_mutable__iiname(); + + 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: + // sint32 _itype = 2; + void clear__itype() ; + ::int32_t _itype() const; + void set__itype(::int32_t value); + + private: + ::int32_t _internal__itype() const; + void _internal_set__itype(::int32_t value); + + public: + // sint32 _ix = 3; + void clear__ix() ; + ::int32_t _ix() const; + void set__ix(::int32_t value); + + private: + ::int32_t _internal__ix() const; + void _internal_set__ix(::int32_t value); + + public: + // sint32 _iy = 4; + void clear__iy() ; + ::int32_t _iy() const; + void set__iy(::int32_t value); + + private: + ::int32_t _internal__iy() const; + void _internal_set__iy(::int32_t value); + + public: + // uint32 _iMagical = 6; + void clear__imagical() ; + ::uint32_t _imagical() const; + void set__imagical(::uint32_t value); + + private: + ::uint32_t _internal__imagical() const; + void _internal_set__imagical(::uint32_t value); + + public: + // uint32 _iClass = 9; + void clear__iclass() ; + ::uint32_t _iclass() const; + void set__iclass(::uint32_t value); + + private: + ::uint32_t _internal__iclass() const; + void _internal_set__iclass(::uint32_t value); + + public: + // sint32 _iCurs = 10; + void clear__icurs() ; + ::int32_t _icurs() const; + void set__icurs(::int32_t value); + + private: + ::int32_t _internal__icurs() const; + void _internal_set__icurs(::int32_t value); + + public: + // sint32 _iValue = 11; + void clear__ivalue() ; + ::int32_t _ivalue() const; + void set__ivalue(::int32_t value); + + private: + ::int32_t _internal__ivalue() const; + void _internal_set__ivalue(::int32_t value); + + public: + // sint32 _iMinDam = 12; + void clear__imindam() ; + ::int32_t _imindam() const; + void set__imindam(::int32_t value); + + private: + ::int32_t _internal__imindam() const; + void _internal_set__imindam(::int32_t value); + + public: + // sint32 _iMaxDam = 13; + void clear__imaxdam() ; + ::int32_t _imaxdam() const; + void set__imaxdam(::int32_t value); + + private: + ::int32_t _internal__imaxdam() const; + void _internal_set__imaxdam(::int32_t value); + + public: + // sint32 _iAC = 14; + void clear__iac() ; + ::int32_t _iac() const; + void set__iac(::int32_t value); + + private: + ::int32_t _internal__iac() const; + void _internal_set__iac(::int32_t value); + + public: + // sint32 _iFlags = 15; + void clear__iflags() ; + ::int32_t _iflags() const; + void set__iflags(::int32_t value); + + private: + ::int32_t _internal__iflags() const; + void _internal_set__iflags(::int32_t value); + + public: + // sint32 _iMiscId = 16; + void clear__imiscid() ; + ::int32_t _imiscid() const; + void set__imiscid(::int32_t value); + + private: + ::int32_t _internal__imiscid() const; + void _internal_set__imiscid(::int32_t value); + + public: + // sint32 _iSpell = 17; + void clear__ispell() ; + ::int32_t _ispell() const; + void set__ispell(::int32_t value); + + private: + ::int32_t _internal__ispell() const; + void _internal_set__ispell(::int32_t value); + + public: + // sint32 _iCharges = 18; + void clear__icharges() ; + ::int32_t _icharges() const; + void set__icharges(::int32_t value); + + private: + ::int32_t _internal__icharges() const; + void _internal_set__icharges(::int32_t value); + + public: + // sint32 _iMaxCharges = 19; + void clear__imaxcharges() ; + ::int32_t _imaxcharges() const; + void set__imaxcharges(::int32_t value); + + private: + ::int32_t _internal__imaxcharges() const; + void _internal_set__imaxcharges(::int32_t value); + + public: + // sint32 _iDurability = 20; + void clear__idurability() ; + ::int32_t _idurability() const; + void set__idurability(::int32_t value); + + private: + ::int32_t _internal__idurability() const; + void _internal_set__idurability(::int32_t value); + + public: + // sint32 _iMaxDur = 21; + void clear__imaxdur() ; + ::int32_t _imaxdur() const; + void set__imaxdur(::int32_t value); + + private: + ::int32_t _internal__imaxdur() const; + void _internal_set__imaxdur(::int32_t value); + + public: + // sint32 _iPLDam = 22; + void clear__ipldam() ; + ::int32_t _ipldam() const; + void set__ipldam(::int32_t value); + + private: + ::int32_t _internal__ipldam() const; + void _internal_set__ipldam(::int32_t value); + + public: + // sint32 _iPLToHit = 23; + void clear__ipltohit() ; + ::int32_t _ipltohit() const; + void set__ipltohit(::int32_t value); + + private: + ::int32_t _internal__ipltohit() const; + void _internal_set__ipltohit(::int32_t value); + + public: + // sint32 _iPLAC = 24; + void clear__iplac() ; + ::int32_t _iplac() const; + void set__iplac(::int32_t value); + + private: + ::int32_t _internal__iplac() const; + void _internal_set__iplac(::int32_t value); + + public: + // sint32 _iPLStr = 25; + void clear__iplstr() ; + ::int32_t _iplstr() const; + void set__iplstr(::int32_t value); + + private: + ::int32_t _internal__iplstr() const; + void _internal_set__iplstr(::int32_t value); + + public: + // sint32 _iPLMag = 26; + void clear__iplmag() ; + ::int32_t _iplmag() const; + void set__iplmag(::int32_t value); + + private: + ::int32_t _internal__iplmag() const; + void _internal_set__iplmag(::int32_t value); + + public: + // bool _iIdentified = 5; + void clear__iidentified() ; + bool _iidentified() const; + void set__iidentified(bool value); + + private: + bool _internal__iidentified() const; + void _internal_set__iidentified(bool value); + + public: + // bool _iStatFlag = 47; + void clear__istatflag() ; + bool _istatflag() const; + void set__istatflag(bool value); + + private: + bool _internal__istatflag() const; + void _internal_set__istatflag(bool value); + + public: + // sint32 _iPLDex = 27; + void clear__ipldex() ; + ::int32_t _ipldex() const; + void set__ipldex(::int32_t value); + + private: + ::int32_t _internal__ipldex() const; + void _internal_set__ipldex(::int32_t value); + + public: + // sint32 _iPLVit = 28; + void clear__iplvit() ; + ::int32_t _iplvit() const; + void set__iplvit(::int32_t value); + + private: + ::int32_t _internal__iplvit() const; + void _internal_set__iplvit(::int32_t value); + + public: + // sint32 _iPLFR = 29; + void clear__iplfr() ; + ::int32_t _iplfr() const; + void set__iplfr(::int32_t value); + + private: + ::int32_t _internal__iplfr() const; + void _internal_set__iplfr(::int32_t value); + + public: + // sint32 _iPLLR = 30; + void clear__ipllr() ; + ::int32_t _ipllr() const; + void set__ipllr(::int32_t value); + + private: + ::int32_t _internal__ipllr() const; + void _internal_set__ipllr(::int32_t value); + + public: + // sint32 _iPLMR = 31; + void clear__iplmr() ; + ::int32_t _iplmr() const; + void set__iplmr(::int32_t value); + + private: + ::int32_t _internal__iplmr() const; + void _internal_set__iplmr(::int32_t value); + + public: + // sint32 _iPLMana = 32; + void clear__iplmana() ; + ::int32_t _iplmana() const; + void set__iplmana(::int32_t value); + + private: + ::int32_t _internal__iplmana() const; + void _internal_set__iplmana(::int32_t value); + + public: + // sint32 _iPLHP = 33; + void clear__iplhp() ; + ::int32_t _iplhp() const; + void set__iplhp(::int32_t value); + + private: + ::int32_t _internal__iplhp() const; + void _internal_set__iplhp(::int32_t value); + + public: + // sint32 _iPLDamMod = 34; + void clear__ipldammod() ; + ::int32_t _ipldammod() const; + void set__ipldammod(::int32_t value); + + private: + ::int32_t _internal__ipldammod() const; + void _internal_set__ipldammod(::int32_t value); + + public: + // sint32 _iPLGetHit = 35; + void clear__iplgethit() ; + ::int32_t _iplgethit() const; + void set__iplgethit(::int32_t value); + + private: + ::int32_t _internal__iplgethit() const; + void _internal_set__iplgethit(::int32_t value); + + public: + // sint32 _iPLLight = 36; + void clear__ipllight() ; + ::int32_t _ipllight() const; + void set__ipllight(::int32_t value); + + private: + ::int32_t _internal__ipllight() const; + void _internal_set__ipllight(::int32_t value); + + public: + // sint32 _iSplLvlAdd = 37; + void clear__ispllvladd() ; + ::int32_t _ispllvladd() const; + void set__ispllvladd(::int32_t value); + + private: + ::int32_t _internal__ispllvladd() const; + void _internal_set__ispllvladd(::int32_t value); + + public: + // sint32 _iFMinDam = 38; + void clear__ifmindam() ; + ::int32_t _ifmindam() const; + void set__ifmindam(::int32_t value); + + private: + ::int32_t _internal__ifmindam() const; + void _internal_set__ifmindam(::int32_t value); + + public: + // sint32 _iFMaxDam = 39; + void clear__ifmaxdam() ; + ::int32_t _ifmaxdam() const; + void set__ifmaxdam(::int32_t value); + + private: + ::int32_t _internal__ifmaxdam() const; + void _internal_set__ifmaxdam(::int32_t value); + + public: + // sint32 _iLMinDam = 40; + void clear__ilmindam() ; + ::int32_t _ilmindam() const; + void set__ilmindam(::int32_t value); + + private: + ::int32_t _internal__ilmindam() const; + void _internal_set__ilmindam(::int32_t value); + + public: + // sint32 _iLMaxDam = 41; + void clear__ilmaxdam() ; + ::int32_t _ilmaxdam() const; + void set__ilmaxdam(::int32_t value); + + private: + ::int32_t _internal__ilmaxdam() const; + void _internal_set__ilmaxdam(::int32_t value); + + public: + // sint32 _iPrePower = 42; + void clear__iprepower() ; + ::int32_t _iprepower() const; + void set__iprepower(::int32_t value); + + private: + ::int32_t _internal__iprepower() const; + void _internal_set__iprepower(::int32_t value); + + public: + // sint32 _iSufPower = 43; + void clear__isufpower() ; + ::int32_t _isufpower() const; + void set__isufpower(::int32_t value); + + private: + ::int32_t _internal__isufpower() const; + void _internal_set__isufpower(::int32_t value); + + public: + // sint32 _iMinStr = 44; + void clear__iminstr() ; + ::int32_t _iminstr() const; + void set__iminstr(::int32_t value); + + private: + ::int32_t _internal__iminstr() const; + void _internal_set__iminstr(::int32_t value); + + public: + // sint32 _iMinMag = 45; + void clear__iminmag() ; + ::int32_t _iminmag() const; + void set__iminmag(::int32_t value); + + private: + ::int32_t _internal__iminmag() const; + void _internal_set__iminmag(::int32_t value); + + public: + // sint32 _iMinDex = 46; + void clear__imindex() ; + ::int32_t _imindex() const; + void set__imindex(::int32_t value); + + private: + ::int32_t _internal__imindex() const; + void _internal_set__imindex(::int32_t value); + + public: + // sint32 IDidx = 48; + void clear_ididx() ; + ::int32_t ididx() const; + void set_ididx(::int32_t value); + + private: + ::int32_t _internal_ididx() const; + void _internal_set_ididx(::int32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.data.ItemData) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 48, 0, + 88, 7> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ItemData& from_msg); + ::google::protobuf::internal::ArenaStringPtr _iname_; + ::google::protobuf::internal::ArenaStringPtr _iiname_; + ::uint32_t id_; + ::int32_t _itype_; + ::int32_t _ix_; + ::int32_t _iy_; + ::uint32_t _imagical_; + ::uint32_t _iclass_; + ::int32_t _icurs_; + ::int32_t _ivalue_; + ::int32_t _imindam_; + ::int32_t _imaxdam_; + ::int32_t _iac_; + ::int32_t _iflags_; + ::int32_t _imiscid_; + ::int32_t _ispell_; + ::int32_t _icharges_; + ::int32_t _imaxcharges_; + ::int32_t _idurability_; + ::int32_t _imaxdur_; + ::int32_t _ipldam_; + ::int32_t _ipltohit_; + ::int32_t _iplac_; + ::int32_t _iplstr_; + ::int32_t _iplmag_; + bool _iidentified_; + bool _istatflag_; + ::int32_t _ipldex_; + ::int32_t _iplvit_; + ::int32_t _iplfr_; + ::int32_t _ipllr_; + ::int32_t _iplmr_; + ::int32_t _iplmana_; + ::int32_t _iplhp_; + ::int32_t _ipldammod_; + ::int32_t _iplgethit_; + ::int32_t _ipllight_; + ::int32_t _ispllvladd_; + ::int32_t _ifmindam_; + ::int32_t _ifmaxdam_; + ::int32_t _ilmindam_; + ::int32_t _ilmaxdam_; + ::int32_t _iprepower_; + ::int32_t _isufpower_; + ::int32_t _iminstr_; + ::int32_t _iminmag_; + ::int32_t _imindex_; + ::int32_t ididx_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_data_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// QuestData + +// uint32 id = 1; +inline void QuestData::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t QuestData::id() const { + // @@protoc_insertion_point(field_get:dapi.data.QuestData.id) + return _internal_id(); +} +inline void QuestData::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.data.QuestData.id) +} +inline ::uint32_t QuestData::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void QuestData::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// uint32 state = 2; +inline void QuestData::clear_state() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.state_ = 0u; +} +inline ::uint32_t QuestData::state() const { + // @@protoc_insertion_point(field_get:dapi.data.QuestData.state) + return _internal_state(); +} +inline void QuestData::set_state(::uint32_t value) { + _internal_set_state(value); + // @@protoc_insertion_point(field_set:dapi.data.QuestData.state) +} +inline ::uint32_t QuestData::_internal_state() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.state_; +} +inline void QuestData::_internal_set_state(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.state_ = value; +} + +// ------------------------------------------------------------------- + +// PortalData + +// uint32 x = 1; +inline void PortalData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0u; +} +inline ::uint32_t PortalData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.PortalData.x) + return _internal_x(); +} +inline void PortalData::set_x(::uint32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.PortalData.x) +} +inline ::uint32_t PortalData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void PortalData::_internal_set_x(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// uint32 y = 2; +inline void PortalData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0u; +} +inline ::uint32_t PortalData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.PortalData.y) + return _internal_y(); +} +inline void PortalData::set_y(::uint32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.PortalData.y) +} +inline ::uint32_t PortalData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void PortalData::_internal_set_y(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// uint32 player = 3; +inline void PortalData::clear_player() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_ = 0u; +} +inline ::uint32_t PortalData::player() const { + // @@protoc_insertion_point(field_get:dapi.data.PortalData.player) + return _internal_player(); +} +inline void PortalData::set_player(::uint32_t value) { + _internal_set_player(value); + // @@protoc_insertion_point(field_set:dapi.data.PortalData.player) +} +inline ::uint32_t PortalData::_internal_player() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_; +} +inline void PortalData::_internal_set_player(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_ = value; +} + +// ------------------------------------------------------------------- + +// MissileData + +// sint32 type = 1; +inline void MissileData::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::int32_t MissileData::type() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.type) + return _internal_type(); +} +inline void MissileData::set_type(::int32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.type) +} +inline ::int32_t MissileData::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void MissileData::_internal_set_type(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// uint32 x = 2; +inline void MissileData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0u; +} +inline ::uint32_t MissileData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.x) + return _internal_x(); +} +inline void MissileData::set_x(::uint32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.x) +} +inline ::uint32_t MissileData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void MissileData::_internal_set_x(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// uint32 y = 3; +inline void MissileData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0u; +} +inline ::uint32_t MissileData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.y) + return _internal_y(); +} +inline void MissileData::set_y(::uint32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.y) +} +inline ::uint32_t MissileData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void MissileData::_internal_set_y(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// sint32 xvel = 4; +inline void MissileData::clear_xvel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.xvel_ = 0; +} +inline ::int32_t MissileData::xvel() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.xvel) + return _internal_xvel(); +} +inline void MissileData::set_xvel(::int32_t value) { + _internal_set_xvel(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.xvel) +} +inline ::int32_t MissileData::_internal_xvel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.xvel_; +} +inline void MissileData::_internal_set_xvel(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.xvel_ = value; +} + +// sint32 yvel = 5; +inline void MissileData::clear_yvel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.yvel_ = 0; +} +inline ::int32_t MissileData::yvel() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.yvel) + return _internal_yvel(); +} +inline void MissileData::set_yvel(::int32_t value) { + _internal_set_yvel(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.yvel) +} +inline ::int32_t MissileData::_internal_yvel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.yvel_; +} +inline void MissileData::_internal_set_yvel(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.yvel_ = value; +} + +// sint32 sx = 6; +inline void MissileData::clear_sx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sx_ = 0; +} +inline ::int32_t MissileData::sx() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.sx) + return _internal_sx(); +} +inline void MissileData::set_sx(::int32_t value) { + _internal_set_sx(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.sx) +} +inline ::int32_t MissileData::_internal_sx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.sx_; +} +inline void MissileData::_internal_set_sx(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sx_ = value; +} + +// sint32 sy = 7; +inline void MissileData::clear_sy() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sy_ = 0; +} +inline ::int32_t MissileData::sy() const { + // @@protoc_insertion_point(field_get:dapi.data.MissileData.sy) + return _internal_sy(); +} +inline void MissileData::set_sy(::int32_t value) { + _internal_set_sy(value); + // @@protoc_insertion_point(field_set:dapi.data.MissileData.sy) +} +inline ::int32_t MissileData::_internal_sy() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.sy_; +} +inline void MissileData::_internal_set_sy(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.sy_ = value; +} + +// ------------------------------------------------------------------- + +// ObjectData + +// uint32 x = 1; +inline void ObjectData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0u; +} +inline ::uint32_t ObjectData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.x) + return _internal_x(); +} +inline void ObjectData::set_x(::uint32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.x) +} +inline ::uint32_t ObjectData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void ObjectData::_internal_set_x(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// uint32 y = 2; +inline void ObjectData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0u; +} +inline ::uint32_t ObjectData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.y) + return _internal_y(); +} +inline void ObjectData::set_y(::uint32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.y) +} +inline ::uint32_t ObjectData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void ObjectData::_internal_set_y(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// sint32 type = 3; +inline void ObjectData::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::int32_t ObjectData::type() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.type) + return _internal_type(); +} +inline void ObjectData::set_type(::int32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.type) +} +inline ::int32_t ObjectData::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void ObjectData::_internal_set_type(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// sint32 shrineType = 4; +inline void ObjectData::clear_shrinetype() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shrinetype_ = 0; +} +inline ::int32_t ObjectData::shrinetype() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.shrineType) + return _internal_shrinetype(); +} +inline void ObjectData::set_shrinetype(::int32_t value) { + _internal_set_shrinetype(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.shrineType) +} +inline ::int32_t ObjectData::_internal_shrinetype() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.shrinetype_; +} +inline void ObjectData::_internal_set_shrinetype(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.shrinetype_ = value; +} + +// bool solid = 5; +inline void ObjectData::clear_solid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.solid_ = false; +} +inline bool ObjectData::solid() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.solid) + return _internal_solid(); +} +inline void ObjectData::set_solid(bool value) { + _internal_set_solid(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.solid) +} +inline bool ObjectData::_internal_solid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.solid_; +} +inline void ObjectData::_internal_set_solid(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.solid_ = value; +} + +// sint32 doorState = 6; +inline void ObjectData::clear_doorstate() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.doorstate_ = 0; +} +inline ::int32_t ObjectData::doorstate() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.doorState) + return _internal_doorstate(); +} +inline void ObjectData::set_doorstate(::int32_t value) { + _internal_set_doorstate(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.doorState) +} +inline ::int32_t ObjectData::_internal_doorstate() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.doorstate_; +} +inline void ObjectData::_internal_set_doorstate(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.doorstate_ = value; +} + +// bool selectable = 7; +inline void ObjectData::clear_selectable() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.selectable_ = false; +} +inline bool ObjectData::selectable() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.selectable) + return _internal_selectable(); +} +inline void ObjectData::set_selectable(bool value) { + _internal_set_selectable(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.selectable) +} +inline bool ObjectData::_internal_selectable() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.selectable_; +} +inline void ObjectData::_internal_set_selectable(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.selectable_ = value; +} + +// uint32 index = 8; +inline void ObjectData::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t ObjectData::index() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.index) + return _internal_index(); +} +inline void ObjectData::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.index) +} +inline ::uint32_t ObjectData::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void ObjectData::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// bool trapped = 9; +inline void ObjectData::clear_trapped() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.trapped_ = false; +} +inline bool ObjectData::trapped() const { + // @@protoc_insertion_point(field_get:dapi.data.ObjectData.trapped) + return _internal_trapped(); +} +inline void ObjectData::set_trapped(bool value) { + _internal_set_trapped(value); + // @@protoc_insertion_point(field_set:dapi.data.ObjectData.trapped) +} +inline bool ObjectData::_internal_trapped() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.trapped_; +} +inline void ObjectData::_internal_set_trapped(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.trapped_ = value; +} + +// ------------------------------------------------------------------- + +// MonsterData + +// uint32 index = 1; +inline void MonsterData::clear_index() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = 0u; +} +inline ::uint32_t MonsterData::index() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.index) + return _internal_index(); +} +inline void MonsterData::set_index(::uint32_t value) { + _internal_set_index(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.index) +} +inline ::uint32_t MonsterData::_internal_index() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.index_; +} +inline void MonsterData::_internal_set_index(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.index_ = value; +} + +// sint32 x = 2; +inline void MonsterData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0; +} +inline ::int32_t MonsterData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.x) + return _internal_x(); +} +inline void MonsterData::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.x) +} +inline ::int32_t MonsterData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void MonsterData::_internal_set_x(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// sint32 y = 3; +inline void MonsterData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0; +} +inline ::int32_t MonsterData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.y) + return _internal_y(); +} +inline void MonsterData::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.y) +} +inline ::int32_t MonsterData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void MonsterData::_internal_set_y(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// sint32 futx = 4; +inline void MonsterData::clear_futx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.futx_ = 0; +} +inline ::int32_t MonsterData::futx() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.futx) + return _internal_futx(); +} +inline void MonsterData::set_futx(::int32_t value) { + _internal_set_futx(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.futx) +} +inline ::int32_t MonsterData::_internal_futx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.futx_; +} +inline void MonsterData::_internal_set_futx(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.futx_ = value; +} + +// sint32 futy = 5; +inline void MonsterData::clear_futy() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.futy_ = 0; +} +inline ::int32_t MonsterData::futy() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.futy) + return _internal_futy(); +} +inline void MonsterData::set_futy(::int32_t value) { + _internal_set_futy(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.futy) +} +inline ::int32_t MonsterData::_internal_futy() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.futy_; +} +inline void MonsterData::_internal_set_futy(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.futy_ = value; +} + +// string name = 6; +inline void MonsterData::clear_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.ClearToEmpty(); +} +inline const std::string& MonsterData::name() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.name) + return _internal_name(); +} +template +inline PROTOBUF_ALWAYS_INLINE void MonsterData::set_name(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.name) +} +inline std::string* MonsterData::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_name(); + // @@protoc_insertion_point(field_mutable:dapi.data.MonsterData.name) + return _s; +} +inline const std::string& MonsterData::_internal_name() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.name_.Get(); +} +inline void MonsterData::_internal_set_name(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.Set(value, GetArena()); +} +inline std::string* MonsterData::_internal_mutable_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.name_.Mutable( GetArena()); +} +inline std::string* MonsterData::release_name() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.data.MonsterData.name) + return _impl_.name_.Release(); +} +inline void MonsterData::set_allocated_name(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.name_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { + _impl_.name_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.data.MonsterData.name) +} + +// sint32 type = 7; +inline void MonsterData::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::int32_t MonsterData::type() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.type) + return _internal_type(); +} +inline void MonsterData::set_type(::int32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.type) +} +inline ::int32_t MonsterData::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void MonsterData::_internal_set_type(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// sint32 kills = 8; +inline void MonsterData::clear_kills() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.kills_ = 0; +} +inline ::int32_t MonsterData::kills() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.kills) + return _internal_kills(); +} +inline void MonsterData::set_kills(::int32_t value) { + _internal_set_kills(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.kills) +} +inline ::int32_t MonsterData::_internal_kills() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.kills_; +} +inline void MonsterData::_internal_set_kills(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.kills_ = value; +} + +// sint32 mode = 9; +inline void MonsterData::clear_mode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mode_ = 0; +} +inline ::int32_t MonsterData::mode() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.mode) + return _internal_mode(); +} +inline void MonsterData::set_mode(::int32_t value) { + _internal_set_mode(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.mode) +} +inline ::int32_t MonsterData::_internal_mode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.mode_; +} +inline void MonsterData::_internal_set_mode(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.mode_ = value; +} + +// bool unique = 10; +inline void MonsterData::clear_unique() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.unique_ = false; +} +inline bool MonsterData::unique() const { + // @@protoc_insertion_point(field_get:dapi.data.MonsterData.unique) + return _internal_unique(); +} +inline void MonsterData::set_unique(bool value) { + _internal_set_unique(value); + // @@protoc_insertion_point(field_set:dapi.data.MonsterData.unique) +} +inline bool MonsterData::_internal_unique() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.unique_; +} +inline void MonsterData::_internal_set_unique(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.unique_ = value; +} + +// ------------------------------------------------------------------- + +// TriggerData + +// uint32 lvl = 1; +inline void TriggerData::clear_lvl() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.lvl_ = 0u; +} +inline ::uint32_t TriggerData::lvl() const { + // @@protoc_insertion_point(field_get:dapi.data.TriggerData.lvl) + return _internal_lvl(); +} +inline void TriggerData::set_lvl(::uint32_t value) { + _internal_set_lvl(value); + // @@protoc_insertion_point(field_set:dapi.data.TriggerData.lvl) +} +inline ::uint32_t TriggerData::_internal_lvl() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.lvl_; +} +inline void TriggerData::_internal_set_lvl(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.lvl_ = value; +} + +// sint32 x = 2; +inline void TriggerData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0; +} +inline ::int32_t TriggerData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.TriggerData.x) + return _internal_x(); +} +inline void TriggerData::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.TriggerData.x) +} +inline ::int32_t TriggerData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void TriggerData::_internal_set_x(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// sint32 y = 3; +inline void TriggerData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0; +} +inline ::int32_t TriggerData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.TriggerData.y) + return _internal_y(); +} +inline void TriggerData::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.TriggerData.y) +} +inline ::int32_t TriggerData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void TriggerData::_internal_set_y(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// sint32 type = 4; +inline void TriggerData::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::int32_t TriggerData::type() const { + // @@protoc_insertion_point(field_get:dapi.data.TriggerData.type) + return _internal_type(); +} +inline void TriggerData::set_type(::int32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.data.TriggerData.type) +} +inline ::int32_t TriggerData::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void TriggerData::_internal_set_type(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// ------------------------------------------------------------------- + +// TileData + +// sint32 type = 1; +inline void TileData::clear_type() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = 0; +} +inline ::int32_t TileData::type() const { + // @@protoc_insertion_point(field_get:dapi.data.TileData.type) + return _internal_type(); +} +inline void TileData::set_type(::int32_t value) { + _internal_set_type(value); + // @@protoc_insertion_point(field_set:dapi.data.TileData.type) +} +inline ::int32_t TileData::_internal_type() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.type_; +} +inline void TileData::_internal_set_type(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.type_ = value; +} + +// bool solid = 2; +inline void TileData::clear_solid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.solid_ = false; +} +inline bool TileData::solid() const { + // @@protoc_insertion_point(field_get:dapi.data.TileData.solid) + return _internal_solid(); +} +inline void TileData::set_solid(bool value) { + _internal_set_solid(value); + // @@protoc_insertion_point(field_set:dapi.data.TileData.solid) +} +inline bool TileData::_internal_solid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.solid_; +} +inline void TileData::_internal_set_solid(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.solid_ = value; +} + +// sint32 x = 3; +inline void TileData::clear_x() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = 0; +} +inline ::int32_t TileData::x() const { + // @@protoc_insertion_point(field_get:dapi.data.TileData.x) + return _internal_x(); +} +inline void TileData::set_x(::int32_t value) { + _internal_set_x(value); + // @@protoc_insertion_point(field_set:dapi.data.TileData.x) +} +inline ::int32_t TileData::_internal_x() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.x_; +} +inline void TileData::_internal_set_x(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.x_ = value; +} + +// sint32 y = 4; +inline void TileData::clear_y() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = 0; +} +inline ::int32_t TileData::y() const { + // @@protoc_insertion_point(field_get:dapi.data.TileData.y) + return _internal_y(); +} +inline void TileData::set_y(::int32_t value) { + _internal_set_y(value); + // @@protoc_insertion_point(field_set:dapi.data.TileData.y) +} +inline ::int32_t TileData::_internal_y() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.y_; +} +inline void TileData::_internal_set_y(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.y_ = value; +} + +// bool stopMissile = 5; +inline void TileData::clear_stopmissile() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stopmissile_ = false; +} +inline bool TileData::stopmissile() const { + // @@protoc_insertion_point(field_get:dapi.data.TileData.stopMissile) + return _internal_stopmissile(); +} +inline void TileData::set_stopmissile(bool value) { + _internal_set_stopmissile(value); + // @@protoc_insertion_point(field_set:dapi.data.TileData.stopMissile) +} +inline bool TileData::_internal_stopmissile() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.stopmissile_; +} +inline void TileData::_internal_set_stopmissile(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stopmissile_ = value; +} + +// ------------------------------------------------------------------- + +// TownerData + +// uint32 ID = 1; +inline void TownerData::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t TownerData::id() const { + // @@protoc_insertion_point(field_get:dapi.data.TownerData.ID) + return _internal_id(); +} +inline void TownerData::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.data.TownerData.ID) +} +inline ::uint32_t TownerData::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void TownerData::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// uint32 _ttype = 2; +inline void TownerData::clear__ttype() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ttype_ = 0u; +} +inline ::uint32_t TownerData::_ttype() const { + // @@protoc_insertion_point(field_get:dapi.data.TownerData._ttype) + return _internal__ttype(); +} +inline void TownerData::set__ttype(::uint32_t value) { + _internal_set__ttype(value); + // @@protoc_insertion_point(field_set:dapi.data.TownerData._ttype) +} +inline ::uint32_t TownerData::_internal__ttype() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ttype_; +} +inline void TownerData::_internal_set__ttype(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ttype_ = value; +} + +// sint32 _tx = 3; +inline void TownerData::clear__tx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tx_ = 0; +} +inline ::int32_t TownerData::_tx() const { + // @@protoc_insertion_point(field_get:dapi.data.TownerData._tx) + return _internal__tx(); +} +inline void TownerData::set__tx(::int32_t value) { + _internal_set__tx(value); + // @@protoc_insertion_point(field_set:dapi.data.TownerData._tx) +} +inline ::int32_t TownerData::_internal__tx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._tx_; +} +inline void TownerData::_internal_set__tx(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tx_ = value; +} + +// sint32 _ty = 4; +inline void TownerData::clear__ty() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ty_ = 0; +} +inline ::int32_t TownerData::_ty() const { + // @@protoc_insertion_point(field_get:dapi.data.TownerData._ty) + return _internal__ty(); +} +inline void TownerData::set__ty(::int32_t value) { + _internal_set__ty(value); + // @@protoc_insertion_point(field_set:dapi.data.TownerData._ty) +} +inline ::int32_t TownerData::_internal__ty() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ty_; +} +inline void TownerData::_internal_set__ty(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ty_ = value; +} + +// string _tName = 5; +inline void TownerData::clear__tname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tname_.ClearToEmpty(); +} +inline const std::string& TownerData::_tname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.data.TownerData._tName) + return _internal__tname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void TownerData::set__tname(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.data.TownerData._tName) +} +inline std::string* TownerData::mutable__tname() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable__tname(); + // @@protoc_insertion_point(field_mutable:dapi.data.TownerData._tName) + return _s; +} +inline const std::string& TownerData::_internal__tname() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._tname_.Get(); +} +inline void TownerData::_internal_set__tname(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tname_.Set(value, GetArena()); +} +inline std::string* TownerData::_internal_mutable__tname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_._tname_.Mutable( GetArena()); +} +inline std::string* TownerData::release__tname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.data.TownerData._tName) + return _impl_._tname_.Release(); +} +inline void TownerData::set_allocated__tname(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._tname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._tname_.IsDefault()) { + _impl_._tname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.data.TownerData._tName) +} + +// ------------------------------------------------------------------- + +// ItemData + +// uint32 ID = 1; +inline void ItemData::clear_id() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = 0u; +} +inline ::uint32_t ItemData::id() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData.ID) + return _internal_id(); +} +inline void ItemData::set_id(::uint32_t value) { + _internal_set_id(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData.ID) +} +inline ::uint32_t ItemData::_internal_id() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.id_; +} +inline void ItemData::_internal_set_id(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.id_ = value; +} + +// sint32 _itype = 2; +inline void ItemData::clear__itype() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._itype_ = 0; +} +inline ::int32_t ItemData::_itype() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._itype) + return _internal__itype(); +} +inline void ItemData::set__itype(::int32_t value) { + _internal_set__itype(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._itype) +} +inline ::int32_t ItemData::_internal__itype() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._itype_; +} +inline void ItemData::_internal_set__itype(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._itype_ = value; +} + +// sint32 _ix = 3; +inline void ItemData::clear__ix() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ix_ = 0; +} +inline ::int32_t ItemData::_ix() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._ix) + return _internal__ix(); +} +inline void ItemData::set__ix(::int32_t value) { + _internal_set__ix(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._ix) +} +inline ::int32_t ItemData::_internal__ix() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ix_; +} +inline void ItemData::_internal_set__ix(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ix_ = value; +} + +// sint32 _iy = 4; +inline void ItemData::clear__iy() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iy_ = 0; +} +inline ::int32_t ItemData::_iy() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iy) + return _internal__iy(); +} +inline void ItemData::set__iy(::int32_t value) { + _internal_set__iy(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iy) +} +inline ::int32_t ItemData::_internal__iy() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iy_; +} +inline void ItemData::_internal_set__iy(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iy_ = value; +} + +// bool _iIdentified = 5; +inline void ItemData::clear__iidentified() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iidentified_ = false; +} +inline bool ItemData::_iidentified() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iIdentified) + return _internal__iidentified(); +} +inline void ItemData::set__iidentified(bool value) { + _internal_set__iidentified(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iIdentified) +} +inline bool ItemData::_internal__iidentified() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iidentified_; +} +inline void ItemData::_internal_set__iidentified(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iidentified_ = value; +} + +// uint32 _iMagical = 6; +inline void ItemData::clear__imagical() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imagical_ = 0u; +} +inline ::uint32_t ItemData::_imagical() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMagical) + return _internal__imagical(); +} +inline void ItemData::set__imagical(::uint32_t value) { + _internal_set__imagical(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMagical) +} +inline ::uint32_t ItemData::_internal__imagical() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imagical_; +} +inline void ItemData::_internal_set__imagical(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imagical_ = value; +} + +// string _iName = 7; +inline void ItemData::clear__iname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iname_.ClearToEmpty(); +} +inline const std::string& ItemData::_iname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iName) + return _internal__iname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ItemData::set__iname(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iName) +} +inline std::string* ItemData::mutable__iname() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable__iname(); + // @@protoc_insertion_point(field_mutable:dapi.data.ItemData._iName) + return _s; +} +inline const std::string& ItemData::_internal__iname() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iname_.Get(); +} +inline void ItemData::_internal_set__iname(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iname_.Set(value, GetArena()); +} +inline std::string* ItemData::_internal_mutable__iname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_._iname_.Mutable( GetArena()); +} +inline std::string* ItemData::release__iname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.data.ItemData._iName) + return _impl_._iname_.Release(); +} +inline void ItemData::set_allocated__iname(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._iname_.IsDefault()) { + _impl_._iname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.data.ItemData._iName) +} + +// string _iIName = 8; +inline void ItemData::clear__iiname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iiname_.ClearToEmpty(); +} +inline const std::string& ItemData::_iiname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iIName) + return _internal__iiname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void ItemData::set__iiname(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iiname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iIName) +} +inline std::string* ItemData::mutable__iiname() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable__iiname(); + // @@protoc_insertion_point(field_mutable:dapi.data.ItemData._iIName) + return _s; +} +inline const std::string& ItemData::_internal__iiname() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iiname_.Get(); +} +inline void ItemData::_internal_set__iiname(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iiname_.Set(value, GetArena()); +} +inline std::string* ItemData::_internal_mutable__iiname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_._iiname_.Mutable( GetArena()); +} +inline std::string* ItemData::release__iiname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.data.ItemData._iIName) + return _impl_._iiname_.Release(); +} +inline void ItemData::set_allocated__iiname(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iiname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._iiname_.IsDefault()) { + _impl_._iiname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.data.ItemData._iIName) +} + +// uint32 _iClass = 9; +inline void ItemData::clear__iclass() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iclass_ = 0u; +} +inline ::uint32_t ItemData::_iclass() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iClass) + return _internal__iclass(); +} +inline void ItemData::set__iclass(::uint32_t value) { + _internal_set__iclass(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iClass) +} +inline ::uint32_t ItemData::_internal__iclass() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iclass_; +} +inline void ItemData::_internal_set__iclass(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iclass_ = value; +} + +// sint32 _iCurs = 10; +inline void ItemData::clear__icurs() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._icurs_ = 0; +} +inline ::int32_t ItemData::_icurs() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iCurs) + return _internal__icurs(); +} +inline void ItemData::set__icurs(::int32_t value) { + _internal_set__icurs(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iCurs) +} +inline ::int32_t ItemData::_internal__icurs() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._icurs_; +} +inline void ItemData::_internal_set__icurs(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._icurs_ = value; +} + +// sint32 _iValue = 11; +inline void ItemData::clear__ivalue() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ivalue_ = 0; +} +inline ::int32_t ItemData::_ivalue() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iValue) + return _internal__ivalue(); +} +inline void ItemData::set__ivalue(::int32_t value) { + _internal_set__ivalue(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iValue) +} +inline ::int32_t ItemData::_internal__ivalue() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ivalue_; +} +inline void ItemData::_internal_set__ivalue(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ivalue_ = value; +} + +// sint32 _iMinDam = 12; +inline void ItemData::clear__imindam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imindam_ = 0; +} +inline ::int32_t ItemData::_imindam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinDam) + return _internal__imindam(); +} +inline void ItemData::set__imindam(::int32_t value) { + _internal_set__imindam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinDam) +} +inline ::int32_t ItemData::_internal__imindam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imindam_; +} +inline void ItemData::_internal_set__imindam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imindam_ = value; +} + +// sint32 _iMaxDam = 13; +inline void ItemData::clear__imaxdam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxdam_ = 0; +} +inline ::int32_t ItemData::_imaxdam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxDam) + return _internal__imaxdam(); +} +inline void ItemData::set__imaxdam(::int32_t value) { + _internal_set__imaxdam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxDam) +} +inline ::int32_t ItemData::_internal__imaxdam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imaxdam_; +} +inline void ItemData::_internal_set__imaxdam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxdam_ = value; +} + +// sint32 _iAC = 14; +inline void ItemData::clear__iac() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iac_ = 0; +} +inline ::int32_t ItemData::_iac() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iAC) + return _internal__iac(); +} +inline void ItemData::set__iac(::int32_t value) { + _internal_set__iac(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iAC) +} +inline ::int32_t ItemData::_internal__iac() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iac_; +} +inline void ItemData::_internal_set__iac(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iac_ = value; +} + +// sint32 _iFlags = 15; +inline void ItemData::clear__iflags() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iflags_ = 0; +} +inline ::int32_t ItemData::_iflags() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFlags) + return _internal__iflags(); +} +inline void ItemData::set__iflags(::int32_t value) { + _internal_set__iflags(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFlags) +} +inline ::int32_t ItemData::_internal__iflags() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iflags_; +} +inline void ItemData::_internal_set__iflags(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iflags_ = value; +} + +// sint32 _iMiscId = 16; +inline void ItemData::clear__imiscid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imiscid_ = 0; +} +inline ::int32_t ItemData::_imiscid() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMiscId) + return _internal__imiscid(); +} +inline void ItemData::set__imiscid(::int32_t value) { + _internal_set__imiscid(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMiscId) +} +inline ::int32_t ItemData::_internal__imiscid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imiscid_; +} +inline void ItemData::_internal_set__imiscid(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imiscid_ = value; +} + +// sint32 _iSpell = 17; +inline void ItemData::clear__ispell() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ispell_ = 0; +} +inline ::int32_t ItemData::_ispell() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSpell) + return _internal__ispell(); +} +inline void ItemData::set__ispell(::int32_t value) { + _internal_set__ispell(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSpell) +} +inline ::int32_t ItemData::_internal__ispell() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ispell_; +} +inline void ItemData::_internal_set__ispell(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ispell_ = value; +} + +// sint32 _iCharges = 18; +inline void ItemData::clear__icharges() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._icharges_ = 0; +} +inline ::int32_t ItemData::_icharges() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iCharges) + return _internal__icharges(); +} +inline void ItemData::set__icharges(::int32_t value) { + _internal_set__icharges(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iCharges) +} +inline ::int32_t ItemData::_internal__icharges() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._icharges_; +} +inline void ItemData::_internal_set__icharges(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._icharges_ = value; +} + +// sint32 _iMaxCharges = 19; +inline void ItemData::clear__imaxcharges() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxcharges_ = 0; +} +inline ::int32_t ItemData::_imaxcharges() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxCharges) + return _internal__imaxcharges(); +} +inline void ItemData::set__imaxcharges(::int32_t value) { + _internal_set__imaxcharges(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxCharges) +} +inline ::int32_t ItemData::_internal__imaxcharges() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imaxcharges_; +} +inline void ItemData::_internal_set__imaxcharges(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxcharges_ = value; +} + +// sint32 _iDurability = 20; +inline void ItemData::clear__idurability() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._idurability_ = 0; +} +inline ::int32_t ItemData::_idurability() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iDurability) + return _internal__idurability(); +} +inline void ItemData::set__idurability(::int32_t value) { + _internal_set__idurability(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iDurability) +} +inline ::int32_t ItemData::_internal__idurability() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._idurability_; +} +inline void ItemData::_internal_set__idurability(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._idurability_ = value; +} + +// sint32 _iMaxDur = 21; +inline void ItemData::clear__imaxdur() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxdur_ = 0; +} +inline ::int32_t ItemData::_imaxdur() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxDur) + return _internal__imaxdur(); +} +inline void ItemData::set__imaxdur(::int32_t value) { + _internal_set__imaxdur(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxDur) +} +inline ::int32_t ItemData::_internal__imaxdur() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imaxdur_; +} +inline void ItemData::_internal_set__imaxdur(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imaxdur_ = value; +} + +// sint32 _iPLDam = 22; +inline void ItemData::clear__ipldam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldam_ = 0; +} +inline ::int32_t ItemData::_ipldam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDam) + return _internal__ipldam(); +} +inline void ItemData::set__ipldam(::int32_t value) { + _internal_set__ipldam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDam) +} +inline ::int32_t ItemData::_internal__ipldam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipldam_; +} +inline void ItemData::_internal_set__ipldam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldam_ = value; +} + +// sint32 _iPLToHit = 23; +inline void ItemData::clear__ipltohit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipltohit_ = 0; +} +inline ::int32_t ItemData::_ipltohit() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLToHit) + return _internal__ipltohit(); +} +inline void ItemData::set__ipltohit(::int32_t value) { + _internal_set__ipltohit(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLToHit) +} +inline ::int32_t ItemData::_internal__ipltohit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipltohit_; +} +inline void ItemData::_internal_set__ipltohit(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipltohit_ = value; +} + +// sint32 _iPLAC = 24; +inline void ItemData::clear__iplac() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplac_ = 0; +} +inline ::int32_t ItemData::_iplac() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLAC) + return _internal__iplac(); +} +inline void ItemData::set__iplac(::int32_t value) { + _internal_set__iplac(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLAC) +} +inline ::int32_t ItemData::_internal__iplac() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplac_; +} +inline void ItemData::_internal_set__iplac(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplac_ = value; +} + +// sint32 _iPLStr = 25; +inline void ItemData::clear__iplstr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplstr_ = 0; +} +inline ::int32_t ItemData::_iplstr() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLStr) + return _internal__iplstr(); +} +inline void ItemData::set__iplstr(::int32_t value) { + _internal_set__iplstr(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLStr) +} +inline ::int32_t ItemData::_internal__iplstr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplstr_; +} +inline void ItemData::_internal_set__iplstr(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplstr_ = value; +} + +// sint32 _iPLMag = 26; +inline void ItemData::clear__iplmag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmag_ = 0; +} +inline ::int32_t ItemData::_iplmag() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMag) + return _internal__iplmag(); +} +inline void ItemData::set__iplmag(::int32_t value) { + _internal_set__iplmag(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMag) +} +inline ::int32_t ItemData::_internal__iplmag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplmag_; +} +inline void ItemData::_internal_set__iplmag(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmag_ = value; +} + +// sint32 _iPLDex = 27; +inline void ItemData::clear__ipldex() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldex_ = 0; +} +inline ::int32_t ItemData::_ipldex() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDex) + return _internal__ipldex(); +} +inline void ItemData::set__ipldex(::int32_t value) { + _internal_set__ipldex(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDex) +} +inline ::int32_t ItemData::_internal__ipldex() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipldex_; +} +inline void ItemData::_internal_set__ipldex(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldex_ = value; +} + +// sint32 _iPLVit = 28; +inline void ItemData::clear__iplvit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplvit_ = 0; +} +inline ::int32_t ItemData::_iplvit() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLVit) + return _internal__iplvit(); +} +inline void ItemData::set__iplvit(::int32_t value) { + _internal_set__iplvit(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLVit) +} +inline ::int32_t ItemData::_internal__iplvit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplvit_; +} +inline void ItemData::_internal_set__iplvit(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplvit_ = value; +} + +// sint32 _iPLFR = 29; +inline void ItemData::clear__iplfr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplfr_ = 0; +} +inline ::int32_t ItemData::_iplfr() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLFR) + return _internal__iplfr(); +} +inline void ItemData::set__iplfr(::int32_t value) { + _internal_set__iplfr(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLFR) +} +inline ::int32_t ItemData::_internal__iplfr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplfr_; +} +inline void ItemData::_internal_set__iplfr(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplfr_ = value; +} + +// sint32 _iPLLR = 30; +inline void ItemData::clear__ipllr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipllr_ = 0; +} +inline ::int32_t ItemData::_ipllr() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLLR) + return _internal__ipllr(); +} +inline void ItemData::set__ipllr(::int32_t value) { + _internal_set__ipllr(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLLR) +} +inline ::int32_t ItemData::_internal__ipllr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipllr_; +} +inline void ItemData::_internal_set__ipllr(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipllr_ = value; +} + +// sint32 _iPLMR = 31; +inline void ItemData::clear__iplmr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmr_ = 0; +} +inline ::int32_t ItemData::_iplmr() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMR) + return _internal__iplmr(); +} +inline void ItemData::set__iplmr(::int32_t value) { + _internal_set__iplmr(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMR) +} +inline ::int32_t ItemData::_internal__iplmr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplmr_; +} +inline void ItemData::_internal_set__iplmr(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmr_ = value; +} + +// sint32 _iPLMana = 32; +inline void ItemData::clear__iplmana() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmana_ = 0; +} +inline ::int32_t ItemData::_iplmana() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMana) + return _internal__iplmana(); +} +inline void ItemData::set__iplmana(::int32_t value) { + _internal_set__iplmana(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMana) +} +inline ::int32_t ItemData::_internal__iplmana() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplmana_; +} +inline void ItemData::_internal_set__iplmana(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplmana_ = value; +} + +// sint32 _iPLHP = 33; +inline void ItemData::clear__iplhp() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplhp_ = 0; +} +inline ::int32_t ItemData::_iplhp() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLHP) + return _internal__iplhp(); +} +inline void ItemData::set__iplhp(::int32_t value) { + _internal_set__iplhp(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLHP) +} +inline ::int32_t ItemData::_internal__iplhp() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplhp_; +} +inline void ItemData::_internal_set__iplhp(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplhp_ = value; +} + +// sint32 _iPLDamMod = 34; +inline void ItemData::clear__ipldammod() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldammod_ = 0; +} +inline ::int32_t ItemData::_ipldammod() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDamMod) + return _internal__ipldammod(); +} +inline void ItemData::set__ipldammod(::int32_t value) { + _internal_set__ipldammod(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDamMod) +} +inline ::int32_t ItemData::_internal__ipldammod() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipldammod_; +} +inline void ItemData::_internal_set__ipldammod(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipldammod_ = value; +} + +// sint32 _iPLGetHit = 35; +inline void ItemData::clear__iplgethit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplgethit_ = 0; +} +inline ::int32_t ItemData::_iplgethit() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLGetHit) + return _internal__iplgethit(); +} +inline void ItemData::set__iplgethit(::int32_t value) { + _internal_set__iplgethit(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLGetHit) +} +inline ::int32_t ItemData::_internal__iplgethit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iplgethit_; +} +inline void ItemData::_internal_set__iplgethit(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iplgethit_ = value; +} + +// sint32 _iPLLight = 36; +inline void ItemData::clear__ipllight() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipllight_ = 0; +} +inline ::int32_t ItemData::_ipllight() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLLight) + return _internal__ipllight(); +} +inline void ItemData::set__ipllight(::int32_t value) { + _internal_set__ipllight(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLLight) +} +inline ::int32_t ItemData::_internal__ipllight() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ipllight_; +} +inline void ItemData::_internal_set__ipllight(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ipllight_ = value; +} + +// sint32 _iSplLvlAdd = 37; +inline void ItemData::clear__ispllvladd() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ispllvladd_ = 0; +} +inline ::int32_t ItemData::_ispllvladd() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSplLvlAdd) + return _internal__ispllvladd(); +} +inline void ItemData::set__ispllvladd(::int32_t value) { + _internal_set__ispllvladd(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSplLvlAdd) +} +inline ::int32_t ItemData::_internal__ispllvladd() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ispllvladd_; +} +inline void ItemData::_internal_set__ispllvladd(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ispllvladd_ = value; +} + +// sint32 _iFMinDam = 38; +inline void ItemData::clear__ifmindam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ifmindam_ = 0; +} +inline ::int32_t ItemData::_ifmindam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFMinDam) + return _internal__ifmindam(); +} +inline void ItemData::set__ifmindam(::int32_t value) { + _internal_set__ifmindam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFMinDam) +} +inline ::int32_t ItemData::_internal__ifmindam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ifmindam_; +} +inline void ItemData::_internal_set__ifmindam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ifmindam_ = value; +} + +// sint32 _iFMaxDam = 39; +inline void ItemData::clear__ifmaxdam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ifmaxdam_ = 0; +} +inline ::int32_t ItemData::_ifmaxdam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFMaxDam) + return _internal__ifmaxdam(); +} +inline void ItemData::set__ifmaxdam(::int32_t value) { + _internal_set__ifmaxdam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFMaxDam) +} +inline ::int32_t ItemData::_internal__ifmaxdam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ifmaxdam_; +} +inline void ItemData::_internal_set__ifmaxdam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ifmaxdam_ = value; +} + +// sint32 _iLMinDam = 40; +inline void ItemData::clear__ilmindam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ilmindam_ = 0; +} +inline ::int32_t ItemData::_ilmindam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iLMinDam) + return _internal__ilmindam(); +} +inline void ItemData::set__ilmindam(::int32_t value) { + _internal_set__ilmindam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iLMinDam) +} +inline ::int32_t ItemData::_internal__ilmindam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ilmindam_; +} +inline void ItemData::_internal_set__ilmindam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ilmindam_ = value; +} + +// sint32 _iLMaxDam = 41; +inline void ItemData::clear__ilmaxdam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ilmaxdam_ = 0; +} +inline ::int32_t ItemData::_ilmaxdam() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iLMaxDam) + return _internal__ilmaxdam(); +} +inline void ItemData::set__ilmaxdam(::int32_t value) { + _internal_set__ilmaxdam(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iLMaxDam) +} +inline ::int32_t ItemData::_internal__ilmaxdam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._ilmaxdam_; +} +inline void ItemData::_internal_set__ilmaxdam(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._ilmaxdam_ = value; +} + +// sint32 _iPrePower = 42; +inline void ItemData::clear__iprepower() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iprepower_ = 0; +} +inline ::int32_t ItemData::_iprepower() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPrePower) + return _internal__iprepower(); +} +inline void ItemData::set__iprepower(::int32_t value) { + _internal_set__iprepower(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPrePower) +} +inline ::int32_t ItemData::_internal__iprepower() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iprepower_; +} +inline void ItemData::_internal_set__iprepower(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iprepower_ = value; +} + +// sint32 _iSufPower = 43; +inline void ItemData::clear__isufpower() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._isufpower_ = 0; +} +inline ::int32_t ItemData::_isufpower() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSufPower) + return _internal__isufpower(); +} +inline void ItemData::set__isufpower(::int32_t value) { + _internal_set__isufpower(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSufPower) +} +inline ::int32_t ItemData::_internal__isufpower() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._isufpower_; +} +inline void ItemData::_internal_set__isufpower(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._isufpower_ = value; +} + +// sint32 _iMinStr = 44; +inline void ItemData::clear__iminstr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iminstr_ = 0; +} +inline ::int32_t ItemData::_iminstr() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinStr) + return _internal__iminstr(); +} +inline void ItemData::set__iminstr(::int32_t value) { + _internal_set__iminstr(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinStr) +} +inline ::int32_t ItemData::_internal__iminstr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iminstr_; +} +inline void ItemData::_internal_set__iminstr(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iminstr_ = value; +} + +// sint32 _iMinMag = 45; +inline void ItemData::clear__iminmag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iminmag_ = 0; +} +inline ::int32_t ItemData::_iminmag() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinMag) + return _internal__iminmag(); +} +inline void ItemData::set__iminmag(::int32_t value) { + _internal_set__iminmag(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinMag) +} +inline ::int32_t ItemData::_internal__iminmag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._iminmag_; +} +inline void ItemData::_internal_set__iminmag(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._iminmag_ = value; +} + +// sint32 _iMinDex = 46; +inline void ItemData::clear__imindex() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imindex_ = 0; +} +inline ::int32_t ItemData::_imindex() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinDex) + return _internal__imindex(); +} +inline void ItemData::set__imindex(::int32_t value) { + _internal_set__imindex(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinDex) +} +inline ::int32_t ItemData::_internal__imindex() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._imindex_; +} +inline void ItemData::_internal_set__imindex(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._imindex_ = value; +} + +// bool _iStatFlag = 47; +inline void ItemData::clear__istatflag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._istatflag_ = false; +} +inline bool ItemData::_istatflag() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData._iStatFlag) + return _internal__istatflag(); +} +inline void ItemData::set__istatflag(bool value) { + _internal_set__istatflag(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData._iStatFlag) +} +inline bool ItemData::_internal__istatflag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._istatflag_; +} +inline void ItemData::_internal_set__istatflag(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._istatflag_ = value; +} + +// sint32 IDidx = 48; +inline void ItemData::clear_ididx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ididx_ = 0; +} +inline ::int32_t ItemData::ididx() const { + // @@protoc_insertion_point(field_get:dapi.data.ItemData.IDidx) + return _internal_ididx(); +} +inline void ItemData::set_ididx(::int32_t value) { + _internal_set_ididx(value); + // @@protoc_insertion_point(field_set:dapi.data.ItemData.IDidx) +} +inline ::int32_t ItemData::_internal_ididx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.ididx_; +} +inline void ItemData::_internal_set_ididx(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.ididx_ = value; +} + +// ------------------------------------------------------------------- + +// PlayerData + +// sint32 _pmode = 1; +inline void PlayerData::clear__pmode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmode_ = 0; +} +inline ::int32_t PlayerData::_pmode() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pmode) + return _internal__pmode(); +} +inline void PlayerData::set__pmode(::int32_t value) { + _internal_set__pmode(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pmode) +} +inline ::int32_t PlayerData::_internal__pmode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmode_; +} +inline void PlayerData::_internal_set__pmode(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmode_ = value; +} + +// sint32 pnum = 2; +inline void PlayerData::clear_pnum() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pnum_ = 0; +} +inline ::int32_t PlayerData::pnum() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.pnum) + return _internal_pnum(); +} +inline void PlayerData::set_pnum(::int32_t value) { + _internal_set_pnum(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.pnum) +} +inline ::int32_t PlayerData::_internal_pnum() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pnum_; +} +inline void PlayerData::_internal_set_pnum(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pnum_ = value; +} + +// sint32 plrlevel = 3; +inline void PlayerData::clear_plrlevel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.plrlevel_ = 0; +} +inline ::int32_t PlayerData::plrlevel() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.plrlevel) + return _internal_plrlevel(); +} +inline void PlayerData::set_plrlevel(::int32_t value) { + _internal_set_plrlevel(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.plrlevel) +} +inline ::int32_t PlayerData::_internal_plrlevel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.plrlevel_; +} +inline void PlayerData::_internal_set_plrlevel(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.plrlevel_ = value; +} + +// sint32 _px = 4; +inline void PlayerData::clear__px() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._px_ = 0; +} +inline ::int32_t PlayerData::_px() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._px) + return _internal__px(); +} +inline void PlayerData::set__px(::int32_t value) { + _internal_set__px(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._px) +} +inline ::int32_t PlayerData::_internal__px() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._px_; +} +inline void PlayerData::_internal_set__px(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._px_ = value; +} + +// sint32 _py = 5; +inline void PlayerData::clear__py() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._py_ = 0; +} +inline ::int32_t PlayerData::_py() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._py) + return _internal__py(); +} +inline void PlayerData::set__py(::int32_t value) { + _internal_set__py(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._py) +} +inline ::int32_t PlayerData::_internal__py() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._py_; +} +inline void PlayerData::_internal_set__py(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._py_ = value; +} + +// sint32 _pfutx = 6; +inline void PlayerData::clear__pfutx() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfutx_ = 0; +} +inline ::int32_t PlayerData::_pfutx() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pfutx) + return _internal__pfutx(); +} +inline void PlayerData::set__pfutx(::int32_t value) { + _internal_set__pfutx(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pfutx) +} +inline ::int32_t PlayerData::_internal__pfutx() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pfutx_; +} +inline void PlayerData::_internal_set__pfutx(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfutx_ = value; +} + +// sint32 _pfuty = 7; +inline void PlayerData::clear__pfuty() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfuty_ = 0; +} +inline ::int32_t PlayerData::_pfuty() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pfuty) + return _internal__pfuty(); +} +inline void PlayerData::set__pfuty(::int32_t value) { + _internal_set__pfuty(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pfuty) +} +inline ::int32_t PlayerData::_internal__pfuty() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pfuty_; +} +inline void PlayerData::_internal_set__pfuty(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfuty_ = value; +} + +// sint32 _pdir = 8; +inline void PlayerData::clear__pdir() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdir_ = 0; +} +inline ::int32_t PlayerData::_pdir() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pdir) + return _internal__pdir(); +} +inline void PlayerData::set__pdir(::int32_t value) { + _internal_set__pdir(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pdir) +} +inline ::int32_t PlayerData::_internal__pdir() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pdir_; +} +inline void PlayerData::_internal_set__pdir(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdir_ = value; +} + +// sint32 _pRSpell = 9; +inline void PlayerData::clear__prspell() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._prspell_ = 0; +} +inline ::int32_t PlayerData::_prspell() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pRSpell) + return _internal__prspell(); +} +inline void PlayerData::set__prspell(::int32_t value) { + _internal_set__prspell(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pRSpell) +} +inline ::int32_t PlayerData::_internal__prspell() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._prspell_; +} +inline void PlayerData::_internal_set__prspell(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._prspell_ = value; +} + +// uint32 _pRsplType = 10; +inline void PlayerData::clear__prspltype() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._prspltype_ = 0u; +} +inline ::uint32_t PlayerData::_prspltype() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pRsplType) + return _internal__prspltype(); +} +inline void PlayerData::set__prspltype(::uint32_t value) { + _internal_set__prspltype(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pRsplType) +} +inline ::uint32_t PlayerData::_internal__prspltype() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._prspltype_; +} +inline void PlayerData::_internal_set__prspltype(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._prspltype_ = value; +} + +// repeated uint32 _pSplLvl = 11; +inline int PlayerData::_internal__pspllvl_size() const { + return _internal__pspllvl().size(); +} +inline int PlayerData::_pspllvl_size() const { + return _internal__pspllvl_size(); +} +inline void PlayerData::clear__pspllvl() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pspllvl_.Clear(); +} +inline ::uint32_t PlayerData::_pspllvl(int index) const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pSplLvl) + return _internal__pspllvl().Get(index); +} +inline void PlayerData::set__pspllvl(int index, ::uint32_t value) { + _internal_mutable__pspllvl()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pSplLvl) +} +inline void PlayerData::add__pspllvl(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable__pspllvl()->Add(value); + // @@protoc_insertion_point(field_add:dapi.data.PlayerData._pSplLvl) +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& PlayerData::_pspllvl() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.data.PlayerData._pSplLvl) + return _internal__pspllvl(); +} +inline ::google::protobuf::RepeatedField<::uint32_t>* PlayerData::mutable__pspllvl() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData._pSplLvl) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable__pspllvl(); +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& +PlayerData::_internal__pspllvl() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pspllvl_; +} +inline ::google::protobuf::RepeatedField<::uint32_t>* PlayerData::_internal_mutable__pspllvl() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_._pspllvl_; +} + +// uint64 _pMemSpells = 12; +inline void PlayerData::clear__pmemspells() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmemspells_ = ::uint64_t{0u}; +} +inline ::uint64_t PlayerData::_pmemspells() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMemSpells) + return _internal__pmemspells(); +} +inline void PlayerData::set__pmemspells(::uint64_t value) { + _internal_set__pmemspells(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMemSpells) +} +inline ::uint64_t PlayerData::_internal__pmemspells() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmemspells_; +} +inline void PlayerData::_internal_set__pmemspells(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmemspells_ = value; +} + +// uint64 _pAblSpells = 13; +inline void PlayerData::clear__pablspells() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pablspells_ = ::uint64_t{0u}; +} +inline ::uint64_t PlayerData::_pablspells() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pAblSpells) + return _internal__pablspells(); +} +inline void PlayerData::set__pablspells(::uint64_t value) { + _internal_set__pablspells(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pAblSpells) +} +inline ::uint64_t PlayerData::_internal__pablspells() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pablspells_; +} +inline void PlayerData::_internal_set__pablspells(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pablspells_ = value; +} + +// uint64 _pScrlSpells = 14; +inline void PlayerData::clear__pscrlspells() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pscrlspells_ = ::uint64_t{0u}; +} +inline ::uint64_t PlayerData::_pscrlspells() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pScrlSpells) + return _internal__pscrlspells(); +} +inline void PlayerData::set__pscrlspells(::uint64_t value) { + _internal_set__pscrlspells(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pScrlSpells) +} +inline ::uint64_t PlayerData::_internal__pscrlspells() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pscrlspells_; +} +inline void PlayerData::_internal_set__pscrlspells(::uint64_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pscrlspells_ = value; +} + +// string _pName = 15; +inline void PlayerData::clear__pname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pname_.ClearToEmpty(); +} +inline const std::string& PlayerData::_pname() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pName) + return _internal__pname(); +} +template +inline PROTOBUF_ALWAYS_INLINE void PlayerData::set__pname(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pname_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pName) +} +inline std::string* PlayerData::mutable__pname() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable__pname(); + // @@protoc_insertion_point(field_mutable:dapi.data.PlayerData._pName) + return _s; +} +inline const std::string& PlayerData::_internal__pname() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pname_.Get(); +} +inline void PlayerData::_internal_set__pname(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pname_.Set(value, GetArena()); +} +inline std::string* PlayerData::_internal_mutable__pname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_._pname_.Mutable( GetArena()); +} +inline std::string* PlayerData::release__pname() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.data.PlayerData._pName) + return _impl_._pname_.Release(); +} +inline void PlayerData::set_allocated__pname(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pname_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._pname_.IsDefault()) { + _impl_._pname_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.data.PlayerData._pName) +} + +// uint32 _pClass = 16; +inline void PlayerData::clear__pclass() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pclass_ = 0u; +} +inline ::uint32_t PlayerData::_pclass() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pClass) + return _internal__pclass(); +} +inline void PlayerData::set__pclass(::uint32_t value) { + _internal_set__pclass(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pClass) +} +inline ::uint32_t PlayerData::_internal__pclass() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pclass_; +} +inline void PlayerData::_internal_set__pclass(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pclass_ = value; +} + +// uint32 _pStrength = 17; +inline void PlayerData::clear__pstrength() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pstrength_ = 0u; +} +inline ::uint32_t PlayerData::_pstrength() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pStrength) + return _internal__pstrength(); +} +inline void PlayerData::set__pstrength(::uint32_t value) { + _internal_set__pstrength(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pStrength) +} +inline ::uint32_t PlayerData::_internal__pstrength() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pstrength_; +} +inline void PlayerData::_internal_set__pstrength(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pstrength_ = value; +} + +// uint32 _pBaseStr = 18; +inline void PlayerData::clear__pbasestr() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasestr_ = 0u; +} +inline ::uint32_t PlayerData::_pbasestr() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseStr) + return _internal__pbasestr(); +} +inline void PlayerData::set__pbasestr(::uint32_t value) { + _internal_set__pbasestr(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseStr) +} +inline ::uint32_t PlayerData::_internal__pbasestr() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pbasestr_; +} +inline void PlayerData::_internal_set__pbasestr(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasestr_ = value; +} + +// uint32 _pMagic = 19; +inline void PlayerData::clear__pmagic() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmagic_ = 0u; +} +inline ::uint32_t PlayerData::_pmagic() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMagic) + return _internal__pmagic(); +} +inline void PlayerData::set__pmagic(::uint32_t value) { + _internal_set__pmagic(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMagic) +} +inline ::uint32_t PlayerData::_internal__pmagic() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmagic_; +} +inline void PlayerData::_internal_set__pmagic(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmagic_ = value; +} + +// uint32 _pBaseMag = 20; +inline void PlayerData::clear__pbasemag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasemag_ = 0u; +} +inline ::uint32_t PlayerData::_pbasemag() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseMag) + return _internal__pbasemag(); +} +inline void PlayerData::set__pbasemag(::uint32_t value) { + _internal_set__pbasemag(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseMag) +} +inline ::uint32_t PlayerData::_internal__pbasemag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pbasemag_; +} +inline void PlayerData::_internal_set__pbasemag(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasemag_ = value; +} + +// uint32 _pDexterity = 21; +inline void PlayerData::clear__pdexterity() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdexterity_ = 0u; +} +inline ::uint32_t PlayerData::_pdexterity() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pDexterity) + return _internal__pdexterity(); +} +inline void PlayerData::set__pdexterity(::uint32_t value) { + _internal_set__pdexterity(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pDexterity) +} +inline ::uint32_t PlayerData::_internal__pdexterity() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pdexterity_; +} +inline void PlayerData::_internal_set__pdexterity(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdexterity_ = value; +} + +// uint32 _pBaseDex = 22; +inline void PlayerData::clear__pbasedex() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasedex_ = 0u; +} +inline ::uint32_t PlayerData::_pbasedex() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseDex) + return _internal__pbasedex(); +} +inline void PlayerData::set__pbasedex(::uint32_t value) { + _internal_set__pbasedex(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseDex) +} +inline ::uint32_t PlayerData::_internal__pbasedex() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pbasedex_; +} +inline void PlayerData::_internal_set__pbasedex(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasedex_ = value; +} + +// uint32 _pVitality = 23; +inline void PlayerData::clear__pvitality() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pvitality_ = 0u; +} +inline ::uint32_t PlayerData::_pvitality() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pVitality) + return _internal__pvitality(); +} +inline void PlayerData::set__pvitality(::uint32_t value) { + _internal_set__pvitality(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pVitality) +} +inline ::uint32_t PlayerData::_internal__pvitality() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pvitality_; +} +inline void PlayerData::_internal_set__pvitality(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pvitality_ = value; +} + +// uint32 _pBaseVit = 24; +inline void PlayerData::clear__pbasevit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasevit_ = 0u; +} +inline ::uint32_t PlayerData::_pbasevit() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseVit) + return _internal__pbasevit(); +} +inline void PlayerData::set__pbasevit(::uint32_t value) { + _internal_set__pbasevit(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseVit) +} +inline ::uint32_t PlayerData::_internal__pbasevit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pbasevit_; +} +inline void PlayerData::_internal_set__pbasevit(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pbasevit_ = value; +} + +// uint32 _pStatPts = 25; +inline void PlayerData::clear__pstatpts() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pstatpts_ = 0u; +} +inline ::uint32_t PlayerData::_pstatpts() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pStatPts) + return _internal__pstatpts(); +} +inline void PlayerData::set__pstatpts(::uint32_t value) { + _internal_set__pstatpts(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pStatPts) +} +inline ::uint32_t PlayerData::_internal__pstatpts() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pstatpts_; +} +inline void PlayerData::_internal_set__pstatpts(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pstatpts_ = value; +} + +// uint32 _pDamageMod = 26; +inline void PlayerData::clear__pdamagemod() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdamagemod_ = 0u; +} +inline ::uint32_t PlayerData::_pdamagemod() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pDamageMod) + return _internal__pdamagemod(); +} +inline void PlayerData::set__pdamagemod(::uint32_t value) { + _internal_set__pdamagemod(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pDamageMod) +} +inline ::uint32_t PlayerData::_internal__pdamagemod() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pdamagemod_; +} +inline void PlayerData::_internal_set__pdamagemod(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pdamagemod_ = value; +} + +// uint32 _pHitPoints = 27; +inline void PlayerData::clear__phitpoints() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._phitpoints_ = 0u; +} +inline ::uint32_t PlayerData::_phitpoints() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pHitPoints) + return _internal__phitpoints(); +} +inline void PlayerData::set__phitpoints(::uint32_t value) { + _internal_set__phitpoints(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pHitPoints) +} +inline ::uint32_t PlayerData::_internal__phitpoints() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._phitpoints_; +} +inline void PlayerData::_internal_set__phitpoints(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._phitpoints_ = value; +} + +// uint32 _pMaxHP = 28; +inline void PlayerData::clear__pmaxhp() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmaxhp_ = 0u; +} +inline ::uint32_t PlayerData::_pmaxhp() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMaxHP) + return _internal__pmaxhp(); +} +inline void PlayerData::set__pmaxhp(::uint32_t value) { + _internal_set__pmaxhp(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMaxHP) +} +inline ::uint32_t PlayerData::_internal__pmaxhp() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmaxhp_; +} +inline void PlayerData::_internal_set__pmaxhp(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmaxhp_ = value; +} + +// sint32 _pMana = 29; +inline void PlayerData::clear__pmana() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmana_ = 0; +} +inline ::int32_t PlayerData::_pmana() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMana) + return _internal__pmana(); +} +inline void PlayerData::set__pmana(::int32_t value) { + _internal_set__pmana(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMana) +} +inline ::int32_t PlayerData::_internal__pmana() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmana_; +} +inline void PlayerData::_internal_set__pmana(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmana_ = value; +} + +// uint32 _pMaxMana = 30; +inline void PlayerData::clear__pmaxmana() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmaxmana_ = 0u; +} +inline ::uint32_t PlayerData::_pmaxmana() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMaxMana) + return _internal__pmaxmana(); +} +inline void PlayerData::set__pmaxmana(::uint32_t value) { + _internal_set__pmaxmana(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMaxMana) +} +inline ::uint32_t PlayerData::_internal__pmaxmana() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmaxmana_; +} +inline void PlayerData::_internal_set__pmaxmana(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmaxmana_ = value; +} + +// uint32 _pLevel = 31; +inline void PlayerData::clear__plevel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._plevel_ = 0u; +} +inline ::uint32_t PlayerData::_plevel() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pLevel) + return _internal__plevel(); +} +inline void PlayerData::set__plevel(::uint32_t value) { + _internal_set__plevel(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pLevel) +} +inline ::uint32_t PlayerData::_internal__plevel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._plevel_; +} +inline void PlayerData::_internal_set__plevel(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._plevel_ = value; +} + +// uint32 _pExperience = 32; +inline void PlayerData::clear__pexperience() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pexperience_ = 0u; +} +inline ::uint32_t PlayerData::_pexperience() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pExperience) + return _internal__pexperience(); +} +inline void PlayerData::set__pexperience(::uint32_t value) { + _internal_set__pexperience(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pExperience) +} +inline ::uint32_t PlayerData::_internal__pexperience() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pexperience_; +} +inline void PlayerData::_internal_set__pexperience(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pexperience_ = value; +} + +// uint32 _pArmorClass = 33; +inline void PlayerData::clear__parmorclass() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._parmorclass_ = 0u; +} +inline ::uint32_t PlayerData::_parmorclass() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pArmorClass) + return _internal__parmorclass(); +} +inline void PlayerData::set__parmorclass(::uint32_t value) { + _internal_set__parmorclass(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pArmorClass) +} +inline ::uint32_t PlayerData::_internal__parmorclass() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._parmorclass_; +} +inline void PlayerData::_internal_set__parmorclass(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._parmorclass_ = value; +} + +// uint32 _pMagResist = 34; +inline void PlayerData::clear__pmagresist() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmagresist_ = 0u; +} +inline ::uint32_t PlayerData::_pmagresist() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMagResist) + return _internal__pmagresist(); +} +inline void PlayerData::set__pmagresist(::uint32_t value) { + _internal_set__pmagresist(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMagResist) +} +inline ::uint32_t PlayerData::_internal__pmagresist() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pmagresist_; +} +inline void PlayerData::_internal_set__pmagresist(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pmagresist_ = value; +} + +// uint32 _pFireResist = 35; +inline void PlayerData::clear__pfireresist() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfireresist_ = 0u; +} +inline ::uint32_t PlayerData::_pfireresist() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pFireResist) + return _internal__pfireresist(); +} +inline void PlayerData::set__pfireresist(::uint32_t value) { + _internal_set__pfireresist(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pFireResist) +} +inline ::uint32_t PlayerData::_internal__pfireresist() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pfireresist_; +} +inline void PlayerData::_internal_set__pfireresist(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pfireresist_ = value; +} + +// uint32 _pLightResist = 36; +inline void PlayerData::clear__plightresist() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._plightresist_ = 0u; +} +inline ::uint32_t PlayerData::_plightresist() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pLightResist) + return _internal__plightresist(); +} +inline void PlayerData::set__plightresist(::uint32_t value) { + _internal_set__plightresist(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pLightResist) +} +inline ::uint32_t PlayerData::_internal__plightresist() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._plightresist_; +} +inline void PlayerData::_internal_set__plightresist(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._plightresist_ = value; +} + +// uint32 _pGold = 37; +inline void PlayerData::clear__pgold() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pgold_ = 0u; +} +inline ::uint32_t PlayerData::_pgold() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pGold) + return _internal__pgold(); +} +inline void PlayerData::set__pgold(::uint32_t value) { + _internal_set__pgold(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pGold) +} +inline ::uint32_t PlayerData::_internal__pgold() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pgold_; +} +inline void PlayerData::_internal_set__pgold(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pgold_ = value; +} + +// repeated sint32 InvBody = 38; +inline int PlayerData::_internal_invbody_size() const { + return _internal_invbody().size(); +} +inline int PlayerData::invbody_size() const { + return _internal_invbody_size(); +} +inline void PlayerData::clear_invbody() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.invbody_.Clear(); +} +inline ::int32_t PlayerData::invbody(int index) const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvBody) + return _internal_invbody().Get(index); +} +inline void PlayerData::set_invbody(int index, ::int32_t value) { + _internal_mutable_invbody()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvBody) +} +inline void PlayerData::add_invbody(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_invbody()->Add(value); + // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvBody) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invbody() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvBody) + return _internal_invbody(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invbody() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvBody) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_invbody(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +PlayerData::_internal_invbody() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.invbody_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invbody() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.invbody_; +} + +// repeated sint32 InvList = 39; +inline int PlayerData::_internal_invlist_size() const { + return _internal_invlist().size(); +} +inline int PlayerData::invlist_size() const { + return _internal_invlist_size(); +} +inline void PlayerData::clear_invlist() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.invlist_.Clear(); +} +inline ::int32_t PlayerData::invlist(int index) const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvList) + return _internal_invlist().Get(index); +} +inline void PlayerData::set_invlist(int index, ::int32_t value) { + _internal_mutable_invlist()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvList) +} +inline void PlayerData::add_invlist(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_invlist()->Add(value); + // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvList) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invlist() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvList) + return _internal_invlist(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invlist() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvList) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_invlist(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +PlayerData::_internal_invlist() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.invlist_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invlist() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.invlist_; +} + +// repeated sint32 InvGrid = 40; +inline int PlayerData::_internal_invgrid_size() const { + return _internal_invgrid().size(); +} +inline int PlayerData::invgrid_size() const { + return _internal_invgrid_size(); +} +inline void PlayerData::clear_invgrid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.invgrid_.Clear(); +} +inline ::int32_t PlayerData::invgrid(int index) const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvGrid) + return _internal_invgrid().Get(index); +} +inline void PlayerData::set_invgrid(int index, ::int32_t value) { + _internal_mutable_invgrid()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvGrid) +} +inline void PlayerData::add_invgrid(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_invgrid()->Add(value); + // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvGrid) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invgrid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvGrid) + return _internal_invgrid(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invgrid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvGrid) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_invgrid(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +PlayerData::_internal_invgrid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.invgrid_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invgrid() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.invgrid_; +} + +// repeated sint32 SpdList = 41; +inline int PlayerData::_internal_spdlist_size() const { + return _internal_spdlist().size(); +} +inline int PlayerData::spdlist_size() const { + return _internal_spdlist_size(); +} +inline void PlayerData::clear_spdlist() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.spdlist_.Clear(); +} +inline ::int32_t PlayerData::spdlist(int index) const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.SpdList) + return _internal_spdlist().Get(index); +} +inline void PlayerData::set_spdlist(int index, ::int32_t value) { + _internal_mutable_spdlist()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.SpdList) +} +inline void PlayerData::add_spdlist(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_spdlist()->Add(value); + // @@protoc_insertion_point(field_add:dapi.data.PlayerData.SpdList) +} +inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::spdlist() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.data.PlayerData.SpdList) + return _internal_spdlist(); +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_spdlist() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.SpdList) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_spdlist(); +} +inline const ::google::protobuf::RepeatedField<::int32_t>& +PlayerData::_internal_spdlist() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.spdlist_; +} +inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_spdlist() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.spdlist_; +} + +// sint32 HoldItem = 42; +inline void PlayerData::clear_holditem() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.holditem_ = 0; +} +inline ::int32_t PlayerData::holditem() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.HoldItem) + return _internal_holditem(); +} +inline void PlayerData::set_holditem(::int32_t value) { + _internal_set_holditem(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.HoldItem) +} +inline ::int32_t PlayerData::_internal_holditem() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.holditem_; +} +inline void PlayerData::_internal_set_holditem(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.holditem_ = value; +} + +// uint32 _pIAC = 43; +inline void PlayerData::clear__piac() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._piac_ = 0u; +} +inline ::uint32_t PlayerData::_piac() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIAC) + return _internal__piac(); +} +inline void PlayerData::set__piac(::uint32_t value) { + _internal_set__piac(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIAC) +} +inline ::uint32_t PlayerData::_internal__piac() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._piac_; +} +inline void PlayerData::_internal_set__piac(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._piac_ = value; +} + +// uint32 _pIMinDam = 44; +inline void PlayerData::clear__pimindam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pimindam_ = 0u; +} +inline ::uint32_t PlayerData::_pimindam() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIMinDam) + return _internal__pimindam(); +} +inline void PlayerData::set__pimindam(::uint32_t value) { + _internal_set__pimindam(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIMinDam) +} +inline ::uint32_t PlayerData::_internal__pimindam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pimindam_; +} +inline void PlayerData::_internal_set__pimindam(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pimindam_ = value; +} + +// uint32 _pIMaxDam = 45; +inline void PlayerData::clear__pimaxdam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pimaxdam_ = 0u; +} +inline ::uint32_t PlayerData::_pimaxdam() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIMaxDam) + return _internal__pimaxdam(); +} +inline void PlayerData::set__pimaxdam(::uint32_t value) { + _internal_set__pimaxdam(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIMaxDam) +} +inline ::uint32_t PlayerData::_internal__pimaxdam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pimaxdam_; +} +inline void PlayerData::_internal_set__pimaxdam(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pimaxdam_ = value; +} + +// uint32 _pIBonusDam = 46; +inline void PlayerData::clear__pibonusdam() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusdam_ = 0u; +} +inline ::uint32_t PlayerData::_pibonusdam() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusDam) + return _internal__pibonusdam(); +} +inline void PlayerData::set__pibonusdam(::uint32_t value) { + _internal_set__pibonusdam(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusDam) +} +inline ::uint32_t PlayerData::_internal__pibonusdam() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pibonusdam_; +} +inline void PlayerData::_internal_set__pibonusdam(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusdam_ = value; +} + +// uint32 _pIBonusToHit = 47; +inline void PlayerData::clear__pibonustohit() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonustohit_ = 0u; +} +inline ::uint32_t PlayerData::_pibonustohit() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusToHit) + return _internal__pibonustohit(); +} +inline void PlayerData::set__pibonustohit(::uint32_t value) { + _internal_set__pibonustohit(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusToHit) +} +inline ::uint32_t PlayerData::_internal__pibonustohit() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pibonustohit_; +} +inline void PlayerData::_internal_set__pibonustohit(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonustohit_ = value; +} + +// uint32 _pIBonusAC = 48; +inline void PlayerData::clear__pibonusac() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusac_ = 0u; +} +inline ::uint32_t PlayerData::_pibonusac() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusAC) + return _internal__pibonusac(); +} +inline void PlayerData::set__pibonusac(::uint32_t value) { + _internal_set__pibonusac(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusAC) +} +inline ::uint32_t PlayerData::_internal__pibonusac() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pibonusac_; +} +inline void PlayerData::_internal_set__pibonusac(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusac_ = value; +} + +// uint32 _pIBonusDamMod = 49; +inline void PlayerData::clear__pibonusdammod() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusdammod_ = 0u; +} +inline ::uint32_t PlayerData::_pibonusdammod() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusDamMod) + return _internal__pibonusdammod(); +} +inline void PlayerData::set__pibonusdammod(::uint32_t value) { + _internal_set__pibonusdammod(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusDamMod) +} +inline ::uint32_t PlayerData::_internal__pibonusdammod() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_._pibonusdammod_; +} +inline void PlayerData::_internal_set__pibonusdammod(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_._pibonusdammod_ = value; +} + +// bool pManaShield = 50; +inline void PlayerData::clear_pmanashield() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pmanashield_ = false; +} +inline bool PlayerData::pmanashield() const { + // @@protoc_insertion_point(field_get:dapi.data.PlayerData.pManaShield) + return _internal_pmanashield(); +} +inline void PlayerData::set_pmanashield(bool value) { + _internal_set_pmanashield(value); + // @@protoc_insertion_point(field_set:dapi.data.PlayerData.pManaShield) +} +inline bool PlayerData::_internal_pmanashield() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pmanashield_; +} +inline void PlayerData::_internal_set_pmanashield(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pmanashield_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace data +} // namespace dapi + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // data_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/game.pb.cc b/Source/dapi/Backend/Messages/generated/game.pb.cc new file mode 100644 index 000000000..257690ffa --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/game.pb.cc @@ -0,0 +1,1115 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: game.proto +// Protobuf C++ Version: 5.29.3 + +#include "game.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace dapi { +namespace game { + +inline constexpr FrameUpdate::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : dpiece_{}, + playerdata_{}, + itemdata_{}, + grounditemid_{}, + _grounditemid_cached_byte_size_{0}, + townerdata_{}, + storeoption_{}, + _storeoption_cached_byte_size_{0}, + storeitems_{}, + _storeitems_cached_byte_size_{0}, + triggerdata_{}, + monsterdata_{}, + objectdata_{}, + missiledata_{}, + portaldata_{}, + questdata_{}, + qtext_( + &::google::protobuf::internal::fixed_address_empty_string, + ::_pbi::ConstantInitialized()), + player_{0u}, + stextflag_{0}, + pausemode_{0}, + cursor_{0u}, + menuopen_{false}, + chrflag_{false}, + invflag_{false}, + qtextflag_{false}, + currlevel_{0u}, + setlevel_{false}, + fps_{0u}, + gamemode_{0u}, + gndifficulty_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR FrameUpdate::FrameUpdate(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct FrameUpdateDefaultTypeInternal { + PROTOBUF_CONSTEXPR FrameUpdateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~FrameUpdateDefaultTypeInternal() {} + union { + FrameUpdate _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrameUpdateDefaultTypeInternal _FrameUpdate_default_instance_; +} // namespace game +} // namespace dapi +namespace dapi { +namespace game { +// =================================================================== + +class FrameUpdate::_Internal { + public: +}; + +void FrameUpdate::clear_dpiece() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.dpiece_.Clear(); +} +void FrameUpdate::clear_playerdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.playerdata_.Clear(); +} +void FrameUpdate::clear_itemdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.itemdata_.Clear(); +} +void FrameUpdate::clear_townerdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.townerdata_.Clear(); +} +void FrameUpdate::clear_triggerdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.triggerdata_.Clear(); +} +void FrameUpdate::clear_monsterdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.monsterdata_.Clear(); +} +void FrameUpdate::clear_objectdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.objectdata_.Clear(); +} +void FrameUpdate::clear_missiledata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.missiledata_.Clear(); +} +void FrameUpdate::clear_portaldata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.portaldata_.Clear(); +} +void FrameUpdate::clear_questdata() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.questdata_.Clear(); +} +FrameUpdate::FrameUpdate(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.game.FrameUpdate) +} +inline PROTOBUF_NDEBUG_INLINE FrameUpdate::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::game::FrameUpdate& from_msg) + : dpiece_{visibility, arena, from.dpiece_}, + playerdata_{visibility, arena, from.playerdata_}, + itemdata_{visibility, arena, from.itemdata_}, + grounditemid_{visibility, arena, from.grounditemid_}, + _grounditemid_cached_byte_size_{0}, + townerdata_{visibility, arena, from.townerdata_}, + storeoption_{visibility, arena, from.storeoption_}, + _storeoption_cached_byte_size_{0}, + storeitems_{visibility, arena, from.storeitems_}, + _storeitems_cached_byte_size_{0}, + triggerdata_{visibility, arena, from.triggerdata_}, + monsterdata_{visibility, arena, from.monsterdata_}, + objectdata_{visibility, arena, from.objectdata_}, + missiledata_{visibility, arena, from.missiledata_}, + portaldata_{visibility, arena, from.portaldata_}, + questdata_{visibility, arena, from.questdata_}, + qtext_(arena, from.qtext_), + _cached_size_{0} {} + +FrameUpdate::FrameUpdate( + ::google::protobuf::Arena* arena, + const FrameUpdate& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + FrameUpdate* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + ::memcpy(reinterpret_cast(&_impl_) + + offsetof(Impl_, player_), + reinterpret_cast(&from._impl_) + + offsetof(Impl_, player_), + offsetof(Impl_, gndifficulty_) - + offsetof(Impl_, player_) + + sizeof(Impl_::gndifficulty_)); + + // @@protoc_insertion_point(copy_constructor:dapi.game.FrameUpdate) +} +inline PROTOBUF_NDEBUG_INLINE FrameUpdate::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : dpiece_{visibility, arena}, + playerdata_{visibility, arena}, + itemdata_{visibility, arena}, + grounditemid_{visibility, arena}, + _grounditemid_cached_byte_size_{0}, + townerdata_{visibility, arena}, + storeoption_{visibility, arena}, + _storeoption_cached_byte_size_{0}, + storeitems_{visibility, arena}, + _storeitems_cached_byte_size_{0}, + triggerdata_{visibility, arena}, + monsterdata_{visibility, arena}, + objectdata_{visibility, arena}, + missiledata_{visibility, arena}, + portaldata_{visibility, arena}, + questdata_{visibility, arena}, + qtext_(arena), + _cached_size_{0} {} + +inline void FrameUpdate::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + ::memset(reinterpret_cast(&_impl_) + + offsetof(Impl_, player_), + 0, + offsetof(Impl_, gndifficulty_) - + offsetof(Impl_, player_) + + sizeof(Impl_::gndifficulty_)); +} +FrameUpdate::~FrameUpdate() { + // @@protoc_insertion_point(destructor:dapi.game.FrameUpdate) + SharedDtor(*this); +} +inline void FrameUpdate::SharedDtor(MessageLite& self) { + FrameUpdate& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.qtext_.Destroy(); + this_._impl_.~Impl_(); +} + +inline void* FrameUpdate::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) FrameUpdate(arena); +} +constexpr auto FrameUpdate::InternalNewImpl_() { + constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_) + + decltype(FrameUpdate::_impl_.dpiece_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_) + + decltype(FrameUpdate::_impl_.playerdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_) + + decltype(FrameUpdate::_impl_.itemdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_) + + decltype(FrameUpdate::_impl_.grounditemid_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_) + + decltype(FrameUpdate::_impl_.townerdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_) + + decltype(FrameUpdate::_impl_.storeoption_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_) + + decltype(FrameUpdate::_impl_.storeitems_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_) + + decltype(FrameUpdate::_impl_.triggerdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_) + + decltype(FrameUpdate::_impl_.monsterdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_) + + decltype(FrameUpdate::_impl_.objectdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_) + + decltype(FrameUpdate::_impl_.missiledata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_) + + decltype(FrameUpdate::_impl_.portaldata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_) + + decltype(FrameUpdate::_impl_.questdata_):: + InternalGetArenaOffset( + ::google::protobuf::MessageLite::internal_visibility()), + }); + if (arena_bits.has_value()) { + return ::google::protobuf::internal::MessageCreator::CopyInit( + sizeof(FrameUpdate), alignof(FrameUpdate), *arena_bits); + } else { + return ::google::protobuf::internal::MessageCreator(&FrameUpdate::PlacementNew_, + sizeof(FrameUpdate), + alignof(FrameUpdate)); + } +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<22> FrameUpdate::_class_data_ = { + { + &_FrameUpdate_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &FrameUpdate::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &FrameUpdate::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &FrameUpdate::ByteSizeLong, + &FrameUpdate::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_._cached_size_), + true, + }, + "dapi.game.FrameUpdate", +}; +const ::google::protobuf::internal::ClassData* FrameUpdate::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<5, 27, 10, 59, 2> FrameUpdate::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 27, 248, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4160749568, // skipmap + offsetof(decltype(_table_), field_entries), + 27, // num_field_entries + 10, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::game::FrameUpdate>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + // uint32 player = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_)}}, + // sint32 stextflag = 2; + {::_pbi::TcParser::FastZ32S1, + {16, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.stextflag_)}}, + // sint32 pauseMode = 3; + {::_pbi::TcParser::FastZ32S1, + {24, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.pausemode_)}}, + // bool menuOpen = 4; + {::_pbi::TcParser::FastV8S1, + {32, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.menuopen_)}}, + // uint32 cursor = 5; + {::_pbi::TcParser::FastV32S1, + {40, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.cursor_)}}, + // bool chrflag = 6; + {::_pbi::TcParser::FastV8S1, + {48, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.chrflag_)}}, + // bool invflag = 7; + {::_pbi::TcParser::FastV8S1, + {56, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.invflag_)}}, + // bool qtextflag = 8; + {::_pbi::TcParser::FastV8S1, + {64, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtextflag_)}}, + // string qtext = 9; + {::_pbi::TcParser::FastUS1, + {74, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtext_)}}, + // uint32 currlevel = 10; + {::_pbi::TcParser::FastV32S1, + {80, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.currlevel_)}}, + // bool setlevel = 11; + {::_pbi::TcParser::FastV8S1, + {88, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.setlevel_)}}, + // uint32 fps = 12; + {::_pbi::TcParser::FastV32S1, + {96, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.fps_)}}, + // uint32 gameMode = 13; + {::_pbi::TcParser::FastV32S1, + {104, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gamemode_)}}, + // uint32 gnDifficulty = 14; + {::_pbi::TcParser::FastV32S1, + {112, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_)}}, + // repeated .dapi.data.TileData dPiece = 15; + {::_pbi::TcParser::FastMtR1, + {122, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_)}}, + // repeated .dapi.data.PlayerData playerData = 16; + {::_pbi::TcParser::FastMtR2, + {386, 63, 1, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_)}}, + // repeated .dapi.data.ItemData itemData = 17; + {::_pbi::TcParser::FastMtR2, + {394, 63, 2, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_)}}, + // repeated uint32 groundItemID = 18; + {::_pbi::TcParser::FastV32P2, + {402, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_)}}, + // repeated .dapi.data.TownerData townerData = 19; + {::_pbi::TcParser::FastMtR2, + {410, 63, 3, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_)}}, + // repeated uint32 storeOption = 20; + {::_pbi::TcParser::FastV32P2, + {418, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_)}}, + // repeated uint32 storeItems = 21; + {::_pbi::TcParser::FastV32P2, + {426, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_)}}, + // repeated .dapi.data.TriggerData triggerData = 22; + {::_pbi::TcParser::FastMtR2, + {434, 63, 4, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_)}}, + // repeated .dapi.data.MonsterData monsterData = 23; + {::_pbi::TcParser::FastMtR2, + {442, 63, 5, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_)}}, + // repeated .dapi.data.ObjectData objectData = 24; + {::_pbi::TcParser::FastMtR2, + {450, 63, 6, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_)}}, + // repeated .dapi.data.MissileData missileData = 25; + {::_pbi::TcParser::FastMtR2, + {458, 63, 7, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_)}}, + // repeated .dapi.data.PortalData portalData = 26; + {::_pbi::TcParser::FastMtR2, + {466, 63, 8, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_)}}, + // repeated .dapi.data.QuestData questData = 27; + {::_pbi::TcParser::FastMtR2, + {474, 63, 9, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_)}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 player = 1; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // sint32 stextflag = 2; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.stextflag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // sint32 pauseMode = 3; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.pausemode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, + // bool menuOpen = 4; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.menuopen_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 cursor = 5; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.cursor_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // bool chrflag = 6; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.chrflag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool invflag = 7; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.invflag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // bool qtextflag = 8; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtextflag_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // string qtext = 9; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtext_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, + // uint32 currlevel = 10; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.currlevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // bool setlevel = 11; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.setlevel_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kBool)}, + // uint32 fps = 12; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.fps_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 gameMode = 13; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gamemode_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // uint32 gnDifficulty = 14; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + // repeated .dapi.data.TileData dPiece = 15; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.PlayerData playerData = 16; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_), 0, 1, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.ItemData itemData = 17; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_), 0, 2, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated uint32 groundItemID = 18; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, + // repeated .dapi.data.TownerData townerData = 19; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_), 0, 3, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated uint32 storeOption = 20; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, + // repeated uint32 storeItems = 21; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_), 0, 0, + (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, + // repeated .dapi.data.TriggerData triggerData = 22; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_), 0, 4, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.MonsterData monsterData = 23; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_), 0, 5, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.ObjectData objectData = 24; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_), 0, 6, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.MissileData missileData = 25; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_), 0, 7, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.PortalData portalData = 26; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_), 0, 8, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + // repeated .dapi.data.QuestData questData = 27; + {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_), 0, 9, + (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::dapi::data::TileData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::PlayerData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::ItemData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::TownerData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::TriggerData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::MonsterData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::ObjectData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::MissileData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::PortalData>()}, + {::_pbi::TcParser::GetTable<::dapi::data::QuestData>()}, + }}, {{ + "\25\0\0\0\0\0\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" + "dapi.game.FrameUpdate" + "qtext" + }}, +}; + +PROTOBUF_NOINLINE void FrameUpdate::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.game.FrameUpdate) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.dpiece_.Clear(); + _impl_.playerdata_.Clear(); + _impl_.itemdata_.Clear(); + _impl_.grounditemid_.Clear(); + _impl_.townerdata_.Clear(); + _impl_.storeoption_.Clear(); + _impl_.storeitems_.Clear(); + _impl_.triggerdata_.Clear(); + _impl_.monsterdata_.Clear(); + _impl_.objectdata_.Clear(); + _impl_.missiledata_.Clear(); + _impl_.portaldata_.Clear(); + _impl_.questdata_.Clear(); + _impl_.qtext_.ClearToEmpty(); + ::memset(&_impl_.player_, 0, static_cast<::size_t>( + reinterpret_cast(&_impl_.gndifficulty_) - + reinterpret_cast(&_impl_.player_)) + sizeof(_impl_.gndifficulty_)); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* FrameUpdate::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const FrameUpdate& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* FrameUpdate::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const FrameUpdate& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.game.FrameUpdate) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 player = 1; + if (this_._internal_player() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_player(), target); + } + + // sint32 stextflag = 2; + if (this_._internal_stextflag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 2, this_._internal_stextflag(), target); + } + + // sint32 pauseMode = 3; + if (this_._internal_pausemode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteSInt32ToArray( + 3, this_._internal_pausemode(), target); + } + + // bool menuOpen = 4; + if (this_._internal_menuopen() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 4, this_._internal_menuopen(), target); + } + + // uint32 cursor = 5; + if (this_._internal_cursor() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 5, this_._internal_cursor(), target); + } + + // bool chrflag = 6; + if (this_._internal_chrflag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 6, this_._internal_chrflag(), target); + } + + // bool invflag = 7; + if (this_._internal_invflag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 7, this_._internal_invflag(), target); + } + + // bool qtextflag = 8; + if (this_._internal_qtextflag() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 8, this_._internal_qtextflag(), target); + } + + // string qtext = 9; + if (!this_._internal_qtext().empty()) { + const std::string& _s = this_._internal_qtext(); + ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( + _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.game.FrameUpdate.qtext"); + target = stream->WriteStringMaybeAliased(9, _s, target); + } + + // uint32 currlevel = 10; + if (this_._internal_currlevel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 10, this_._internal_currlevel(), target); + } + + // bool setlevel = 11; + if (this_._internal_setlevel() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteBoolToArray( + 11, this_._internal_setlevel(), target); + } + + // uint32 fps = 12; + if (this_._internal_fps() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 12, this_._internal_fps(), target); + } + + // uint32 gameMode = 13; + if (this_._internal_gamemode() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 13, this_._internal_gamemode(), target); + } + + // uint32 gnDifficulty = 14; + if (this_._internal_gndifficulty() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 14, this_._internal_gndifficulty(), target); + } + + // repeated .dapi.data.TileData dPiece = 15; + for (unsigned i = 0, n = static_cast( + this_._internal_dpiece_size()); + i < n; i++) { + const auto& repfield = this_._internal_dpiece().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 15, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.PlayerData playerData = 16; + for (unsigned i = 0, n = static_cast( + this_._internal_playerdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_playerdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 16, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.ItemData itemData = 17; + for (unsigned i = 0, n = static_cast( + this_._internal_itemdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_itemdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 17, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated uint32 groundItemID = 18; + { + int byte_size = this_._impl_._grounditemid_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 18, this_._internal_grounditemid(), byte_size, target); + } + } + + // repeated .dapi.data.TownerData townerData = 19; + for (unsigned i = 0, n = static_cast( + this_._internal_townerdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_townerdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 19, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated uint32 storeOption = 20; + { + int byte_size = this_._impl_._storeoption_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 20, this_._internal_storeoption(), byte_size, target); + } + } + + // repeated uint32 storeItems = 21; + { + int byte_size = this_._impl_._storeitems_cached_byte_size_.Get(); + if (byte_size > 0) { + target = stream->WriteUInt32Packed( + 21, this_._internal_storeitems(), byte_size, target); + } + } + + // repeated .dapi.data.TriggerData triggerData = 22; + for (unsigned i = 0, n = static_cast( + this_._internal_triggerdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_triggerdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 22, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.MonsterData monsterData = 23; + for (unsigned i = 0, n = static_cast( + this_._internal_monsterdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_monsterdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 23, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.ObjectData objectData = 24; + for (unsigned i = 0, n = static_cast( + this_._internal_objectdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_objectdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 24, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.MissileData missileData = 25; + for (unsigned i = 0, n = static_cast( + this_._internal_missiledata_size()); + i < n; i++) { + const auto& repfield = this_._internal_missiledata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 25, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.PortalData portalData = 26; + for (unsigned i = 0, n = static_cast( + this_._internal_portaldata_size()); + i < n; i++) { + const auto& repfield = this_._internal_portaldata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 26, repfield, repfield.GetCachedSize(), + target, stream); + } + + // repeated .dapi.data.QuestData questData = 27; + for (unsigned i = 0, n = static_cast( + this_._internal_questdata_size()); + i < n; i++) { + const auto& repfield = this_._internal_questdata().Get(i); + target = + ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 27, repfield, repfield.GetCachedSize(), + target, stream); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.game.FrameUpdate) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t FrameUpdate::ByteSizeLong(const MessageLite& base) { + const FrameUpdate& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t FrameUpdate::ByteSizeLong() const { + const FrameUpdate& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.game.FrameUpdate) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + ::_pbi::Prefetch5LinesFrom7Lines(&this_); + { + // repeated .dapi.data.TileData dPiece = 15; + { + total_size += 1UL * this_._internal_dpiece_size(); + for (const auto& msg : this_._internal_dpiece()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.PlayerData playerData = 16; + { + total_size += 2UL * this_._internal_playerdata_size(); + for (const auto& msg : this_._internal_playerdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.ItemData itemData = 17; + { + total_size += 2UL * this_._internal_itemdata_size(); + for (const auto& msg : this_._internal_itemdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated uint32 groundItemID = 18; + { + total_size += + ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( + this_._internal_grounditemid(), 2, + this_._impl_._grounditemid_cached_byte_size_); + } + // repeated .dapi.data.TownerData townerData = 19; + { + total_size += 2UL * this_._internal_townerdata_size(); + for (const auto& msg : this_._internal_townerdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated uint32 storeOption = 20; + { + total_size += + ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( + this_._internal_storeoption(), 2, + this_._impl_._storeoption_cached_byte_size_); + } + // repeated uint32 storeItems = 21; + { + total_size += + ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( + this_._internal_storeitems(), 2, + this_._impl_._storeitems_cached_byte_size_); + } + // repeated .dapi.data.TriggerData triggerData = 22; + { + total_size += 2UL * this_._internal_triggerdata_size(); + for (const auto& msg : this_._internal_triggerdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.MonsterData monsterData = 23; + { + total_size += 2UL * this_._internal_monsterdata_size(); + for (const auto& msg : this_._internal_monsterdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.ObjectData objectData = 24; + { + total_size += 2UL * this_._internal_objectdata_size(); + for (const auto& msg : this_._internal_objectdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.MissileData missileData = 25; + { + total_size += 2UL * this_._internal_missiledata_size(); + for (const auto& msg : this_._internal_missiledata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.PortalData portalData = 26; + { + total_size += 2UL * this_._internal_portaldata_size(); + for (const auto& msg : this_._internal_portaldata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + // repeated .dapi.data.QuestData questData = 27; + { + total_size += 2UL * this_._internal_questdata_size(); + for (const auto& msg : this_._internal_questdata()) { + total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); + } + } + } + { + // string qtext = 9; + if (!this_._internal_qtext().empty()) { + total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( + this_._internal_qtext()); + } + // uint32 player = 1; + if (this_._internal_player() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_player()); + } + // sint32 stextflag = 2; + if (this_._internal_stextflag() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_stextflag()); + } + // sint32 pauseMode = 3; + if (this_._internal_pausemode() != 0) { + total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( + this_._internal_pausemode()); + } + // uint32 cursor = 5; + if (this_._internal_cursor() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_cursor()); + } + // bool menuOpen = 4; + if (this_._internal_menuopen() != 0) { + total_size += 2; + } + // bool chrflag = 6; + if (this_._internal_chrflag() != 0) { + total_size += 2; + } + // bool invflag = 7; + if (this_._internal_invflag() != 0) { + total_size += 2; + } + // bool qtextflag = 8; + if (this_._internal_qtextflag() != 0) { + total_size += 2; + } + // uint32 currlevel = 10; + if (this_._internal_currlevel() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_currlevel()); + } + // bool setlevel = 11; + if (this_._internal_setlevel() != 0) { + total_size += 2; + } + // uint32 fps = 12; + if (this_._internal_fps() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_fps()); + } + // uint32 gameMode = 13; + if (this_._internal_gamemode() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_gamemode()); + } + // uint32 gnDifficulty = 14; + if (this_._internal_gndifficulty() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_gndifficulty()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void FrameUpdate::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.game.FrameUpdate) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_mutable_dpiece()->MergeFrom( + from._internal_dpiece()); + _this->_internal_mutable_playerdata()->MergeFrom( + from._internal_playerdata()); + _this->_internal_mutable_itemdata()->MergeFrom( + from._internal_itemdata()); + _this->_internal_mutable_grounditemid()->MergeFrom(from._internal_grounditemid()); + _this->_internal_mutable_townerdata()->MergeFrom( + from._internal_townerdata()); + _this->_internal_mutable_storeoption()->MergeFrom(from._internal_storeoption()); + _this->_internal_mutable_storeitems()->MergeFrom(from._internal_storeitems()); + _this->_internal_mutable_triggerdata()->MergeFrom( + from._internal_triggerdata()); + _this->_internal_mutable_monsterdata()->MergeFrom( + from._internal_monsterdata()); + _this->_internal_mutable_objectdata()->MergeFrom( + from._internal_objectdata()); + _this->_internal_mutable_missiledata()->MergeFrom( + from._internal_missiledata()); + _this->_internal_mutable_portaldata()->MergeFrom( + from._internal_portaldata()); + _this->_internal_mutable_questdata()->MergeFrom( + from._internal_questdata()); + if (!from._internal_qtext().empty()) { + _this->_internal_set_qtext(from._internal_qtext()); + } + if (from._internal_player() != 0) { + _this->_impl_.player_ = from._impl_.player_; + } + if (from._internal_stextflag() != 0) { + _this->_impl_.stextflag_ = from._impl_.stextflag_; + } + if (from._internal_pausemode() != 0) { + _this->_impl_.pausemode_ = from._impl_.pausemode_; + } + if (from._internal_cursor() != 0) { + _this->_impl_.cursor_ = from._impl_.cursor_; + } + if (from._internal_menuopen() != 0) { + _this->_impl_.menuopen_ = from._impl_.menuopen_; + } + if (from._internal_chrflag() != 0) { + _this->_impl_.chrflag_ = from._impl_.chrflag_; + } + if (from._internal_invflag() != 0) { + _this->_impl_.invflag_ = from._impl_.invflag_; + } + if (from._internal_qtextflag() != 0) { + _this->_impl_.qtextflag_ = from._impl_.qtextflag_; + } + if (from._internal_currlevel() != 0) { + _this->_impl_.currlevel_ = from._impl_.currlevel_; + } + if (from._internal_setlevel() != 0) { + _this->_impl_.setlevel_ = from._impl_.setlevel_; + } + if (from._internal_fps() != 0) { + _this->_impl_.fps_ = from._impl_.fps_; + } + if (from._internal_gamemode() != 0) { + _this->_impl_.gamemode_ = from._impl_.gamemode_; + } + if (from._internal_gndifficulty() != 0) { + _this->_impl_.gndifficulty_ = from._impl_.gndifficulty_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void FrameUpdate::CopyFrom(const FrameUpdate& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.game.FrameUpdate) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void FrameUpdate::InternalSwap(FrameUpdate* PROTOBUF_RESTRICT other) { + using std::swap; + auto* arena = GetArena(); + ABSL_DCHECK_EQ(arena, other->GetArena()); + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + _impl_.dpiece_.InternalSwap(&other->_impl_.dpiece_); + _impl_.playerdata_.InternalSwap(&other->_impl_.playerdata_); + _impl_.itemdata_.InternalSwap(&other->_impl_.itemdata_); + _impl_.grounditemid_.InternalSwap(&other->_impl_.grounditemid_); + _impl_.townerdata_.InternalSwap(&other->_impl_.townerdata_); + _impl_.storeoption_.InternalSwap(&other->_impl_.storeoption_); + _impl_.storeitems_.InternalSwap(&other->_impl_.storeitems_); + _impl_.triggerdata_.InternalSwap(&other->_impl_.triggerdata_); + _impl_.monsterdata_.InternalSwap(&other->_impl_.monsterdata_); + _impl_.objectdata_.InternalSwap(&other->_impl_.objectdata_); + _impl_.missiledata_.InternalSwap(&other->_impl_.missiledata_); + _impl_.portaldata_.InternalSwap(&other->_impl_.portaldata_); + _impl_.questdata_.InternalSwap(&other->_impl_.questdata_); + ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.qtext_, &other->_impl_.qtext_, arena); + ::google::protobuf::internal::memswap< + PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_) + + sizeof(FrameUpdate::_impl_.gndifficulty_) + - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_)>( + reinterpret_cast(&_impl_.player_), + reinterpret_cast(&other->_impl_.player_)); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace game +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/game.pb.h b/Source/dapi/Backend/Messages/generated/game.pb.h new file mode 100644 index 000000000..c4c7909e1 --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/game.pb.h @@ -0,0 +1,1609 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: game.proto +// Protobuf C++ Version: 5.29.3 + +#ifndef game_2eproto_2epb_2eh +#define game_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029003 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "data.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_game_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_game_2eproto { + static const ::uint32_t offsets[]; +}; +namespace dapi { +namespace game { +class FrameUpdate; +struct FrameUpdateDefaultTypeInternal; +extern FrameUpdateDefaultTypeInternal _FrameUpdate_default_instance_; +} // namespace game +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace dapi { +namespace game { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class FrameUpdate final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.game.FrameUpdate) */ { + public: + inline FrameUpdate() : FrameUpdate(nullptr) {} + ~FrameUpdate() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(FrameUpdate* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(FrameUpdate)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR FrameUpdate( + ::google::protobuf::internal::ConstantInitialized); + + inline FrameUpdate(const FrameUpdate& from) : FrameUpdate(nullptr, from) {} + inline FrameUpdate(FrameUpdate&& from) noexcept + : FrameUpdate(nullptr, std::move(from)) {} + inline FrameUpdate& operator=(const FrameUpdate& from) { + CopyFrom(from); + return *this; + } + inline FrameUpdate& operator=(FrameUpdate&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const FrameUpdate& default_instance() { + return *internal_default_instance(); + } + static inline const FrameUpdate* internal_default_instance() { + return reinterpret_cast( + &_FrameUpdate_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(FrameUpdate& a, FrameUpdate& b) { a.Swap(&b); } + inline void Swap(FrameUpdate* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(FrameUpdate* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + FrameUpdate* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const FrameUpdate& from); + void MergeFrom(const FrameUpdate& from) { FrameUpdate::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(FrameUpdate* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.game.FrameUpdate"; } + + protected: + explicit FrameUpdate(::google::protobuf::Arena* arena); + FrameUpdate(::google::protobuf::Arena* arena, const FrameUpdate& from); + FrameUpdate(::google::protobuf::Arena* arena, FrameUpdate&& from) noexcept + : FrameUpdate(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kDPieceFieldNumber = 15, + kPlayerDataFieldNumber = 16, + kItemDataFieldNumber = 17, + kGroundItemIDFieldNumber = 18, + kTownerDataFieldNumber = 19, + kStoreOptionFieldNumber = 20, + kStoreItemsFieldNumber = 21, + kTriggerDataFieldNumber = 22, + kMonsterDataFieldNumber = 23, + kObjectDataFieldNumber = 24, + kMissileDataFieldNumber = 25, + kPortalDataFieldNumber = 26, + kQuestDataFieldNumber = 27, + kQtextFieldNumber = 9, + kPlayerFieldNumber = 1, + kStextflagFieldNumber = 2, + kPauseModeFieldNumber = 3, + kCursorFieldNumber = 5, + kMenuOpenFieldNumber = 4, + kChrflagFieldNumber = 6, + kInvflagFieldNumber = 7, + kQtextflagFieldNumber = 8, + kCurrlevelFieldNumber = 10, + kSetlevelFieldNumber = 11, + kFpsFieldNumber = 12, + kGameModeFieldNumber = 13, + kGnDifficultyFieldNumber = 14, + }; + // repeated .dapi.data.TileData dPiece = 15; + int dpiece_size() const; + private: + int _internal_dpiece_size() const; + + public: + void clear_dpiece() ; + ::dapi::data::TileData* mutable_dpiece(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* mutable_dpiece(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& _internal_dpiece() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* _internal_mutable_dpiece(); + public: + const ::dapi::data::TileData& dpiece(int index) const; + ::dapi::data::TileData* add_dpiece(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& dpiece() const; + // repeated .dapi.data.PlayerData playerData = 16; + int playerdata_size() const; + private: + int _internal_playerdata_size() const; + + public: + void clear_playerdata() ; + ::dapi::data::PlayerData* mutable_playerdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* mutable_playerdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& _internal_playerdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* _internal_mutable_playerdata(); + public: + const ::dapi::data::PlayerData& playerdata(int index) const; + ::dapi::data::PlayerData* add_playerdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& playerdata() const; + // repeated .dapi.data.ItemData itemData = 17; + int itemdata_size() const; + private: + int _internal_itemdata_size() const; + + public: + void clear_itemdata() ; + ::dapi::data::ItemData* mutable_itemdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* mutable_itemdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& _internal_itemdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* _internal_mutable_itemdata(); + public: + const ::dapi::data::ItemData& itemdata(int index) const; + ::dapi::data::ItemData* add_itemdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& itemdata() const; + // repeated uint32 groundItemID = 18; + int grounditemid_size() const; + private: + int _internal_grounditemid_size() const; + + public: + void clear_grounditemid() ; + ::uint32_t grounditemid(int index) const; + void set_grounditemid(int index, ::uint32_t value); + void add_grounditemid(::uint32_t value); + const ::google::protobuf::RepeatedField<::uint32_t>& grounditemid() const; + ::google::protobuf::RepeatedField<::uint32_t>* mutable_grounditemid(); + + private: + const ::google::protobuf::RepeatedField<::uint32_t>& _internal_grounditemid() const; + ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_grounditemid(); + + public: + // repeated .dapi.data.TownerData townerData = 19; + int townerdata_size() const; + private: + int _internal_townerdata_size() const; + + public: + void clear_townerdata() ; + ::dapi::data::TownerData* mutable_townerdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* mutable_townerdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& _internal_townerdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* _internal_mutable_townerdata(); + public: + const ::dapi::data::TownerData& townerdata(int index) const; + ::dapi::data::TownerData* add_townerdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& townerdata() const; + // repeated uint32 storeOption = 20; + int storeoption_size() const; + private: + int _internal_storeoption_size() const; + + public: + void clear_storeoption() ; + ::uint32_t storeoption(int index) const; + void set_storeoption(int index, ::uint32_t value); + void add_storeoption(::uint32_t value); + const ::google::protobuf::RepeatedField<::uint32_t>& storeoption() const; + ::google::protobuf::RepeatedField<::uint32_t>* mutable_storeoption(); + + private: + const ::google::protobuf::RepeatedField<::uint32_t>& _internal_storeoption() const; + ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_storeoption(); + + public: + // repeated uint32 storeItems = 21; + int storeitems_size() const; + private: + int _internal_storeitems_size() const; + + public: + void clear_storeitems() ; + ::uint32_t storeitems(int index) const; + void set_storeitems(int index, ::uint32_t value); + void add_storeitems(::uint32_t value); + const ::google::protobuf::RepeatedField<::uint32_t>& storeitems() const; + ::google::protobuf::RepeatedField<::uint32_t>* mutable_storeitems(); + + private: + const ::google::protobuf::RepeatedField<::uint32_t>& _internal_storeitems() const; + ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_storeitems(); + + public: + // repeated .dapi.data.TriggerData triggerData = 22; + int triggerdata_size() const; + private: + int _internal_triggerdata_size() const; + + public: + void clear_triggerdata() ; + ::dapi::data::TriggerData* mutable_triggerdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* mutable_triggerdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& _internal_triggerdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* _internal_mutable_triggerdata(); + public: + const ::dapi::data::TriggerData& triggerdata(int index) const; + ::dapi::data::TriggerData* add_triggerdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& triggerdata() const; + // repeated .dapi.data.MonsterData monsterData = 23; + int monsterdata_size() const; + private: + int _internal_monsterdata_size() const; + + public: + void clear_monsterdata() ; + ::dapi::data::MonsterData* mutable_monsterdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* mutable_monsterdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& _internal_monsterdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* _internal_mutable_monsterdata(); + public: + const ::dapi::data::MonsterData& monsterdata(int index) const; + ::dapi::data::MonsterData* add_monsterdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& monsterdata() const; + // repeated .dapi.data.ObjectData objectData = 24; + int objectdata_size() const; + private: + int _internal_objectdata_size() const; + + public: + void clear_objectdata() ; + ::dapi::data::ObjectData* mutable_objectdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* mutable_objectdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& _internal_objectdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* _internal_mutable_objectdata(); + public: + const ::dapi::data::ObjectData& objectdata(int index) const; + ::dapi::data::ObjectData* add_objectdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& objectdata() const; + // repeated .dapi.data.MissileData missileData = 25; + int missiledata_size() const; + private: + int _internal_missiledata_size() const; + + public: + void clear_missiledata() ; + ::dapi::data::MissileData* mutable_missiledata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* mutable_missiledata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& _internal_missiledata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* _internal_mutable_missiledata(); + public: + const ::dapi::data::MissileData& missiledata(int index) const; + ::dapi::data::MissileData* add_missiledata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& missiledata() const; + // repeated .dapi.data.PortalData portalData = 26; + int portaldata_size() const; + private: + int _internal_portaldata_size() const; + + public: + void clear_portaldata() ; + ::dapi::data::PortalData* mutable_portaldata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* mutable_portaldata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& _internal_portaldata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* _internal_mutable_portaldata(); + public: + const ::dapi::data::PortalData& portaldata(int index) const; + ::dapi::data::PortalData* add_portaldata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& portaldata() const; + // repeated .dapi.data.QuestData questData = 27; + int questdata_size() const; + private: + int _internal_questdata_size() const; + + public: + void clear_questdata() ; + ::dapi::data::QuestData* mutable_questdata(int index); + ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* mutable_questdata(); + + private: + const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& _internal_questdata() const; + ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* _internal_mutable_questdata(); + public: + const ::dapi::data::QuestData& questdata(int index) const; + ::dapi::data::QuestData* add_questdata(); + const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& questdata() const; + // string qtext = 9; + void clear_qtext() ; + const std::string& qtext() const; + template + void set_qtext(Arg_&& arg, Args_... args); + std::string* mutable_qtext(); + PROTOBUF_NODISCARD std::string* release_qtext(); + void set_allocated_qtext(std::string* value); + + private: + const std::string& _internal_qtext() const; + inline PROTOBUF_ALWAYS_INLINE void _internal_set_qtext( + const std::string& value); + std::string* _internal_mutable_qtext(); + + public: + // uint32 player = 1; + void clear_player() ; + ::uint32_t player() const; + void set_player(::uint32_t value); + + private: + ::uint32_t _internal_player() const; + void _internal_set_player(::uint32_t value); + + public: + // sint32 stextflag = 2; + void clear_stextflag() ; + ::int32_t stextflag() const; + void set_stextflag(::int32_t value); + + private: + ::int32_t _internal_stextflag() const; + void _internal_set_stextflag(::int32_t value); + + public: + // sint32 pauseMode = 3; + void clear_pausemode() ; + ::int32_t pausemode() const; + void set_pausemode(::int32_t value); + + private: + ::int32_t _internal_pausemode() const; + void _internal_set_pausemode(::int32_t value); + + public: + // uint32 cursor = 5; + void clear_cursor() ; + ::uint32_t cursor() const; + void set_cursor(::uint32_t value); + + private: + ::uint32_t _internal_cursor() const; + void _internal_set_cursor(::uint32_t value); + + public: + // bool menuOpen = 4; + void clear_menuopen() ; + bool menuopen() const; + void set_menuopen(bool value); + + private: + bool _internal_menuopen() const; + void _internal_set_menuopen(bool value); + + public: + // bool chrflag = 6; + void clear_chrflag() ; + bool chrflag() const; + void set_chrflag(bool value); + + private: + bool _internal_chrflag() const; + void _internal_set_chrflag(bool value); + + public: + // bool invflag = 7; + void clear_invflag() ; + bool invflag() const; + void set_invflag(bool value); + + private: + bool _internal_invflag() const; + void _internal_set_invflag(bool value); + + public: + // bool qtextflag = 8; + void clear_qtextflag() ; + bool qtextflag() const; + void set_qtextflag(bool value); + + private: + bool _internal_qtextflag() const; + void _internal_set_qtextflag(bool value); + + public: + // uint32 currlevel = 10; + void clear_currlevel() ; + ::uint32_t currlevel() const; + void set_currlevel(::uint32_t value); + + private: + ::uint32_t _internal_currlevel() const; + void _internal_set_currlevel(::uint32_t value); + + public: + // bool setlevel = 11; + void clear_setlevel() ; + bool setlevel() const; + void set_setlevel(bool value); + + private: + bool _internal_setlevel() const; + void _internal_set_setlevel(bool value); + + public: + // uint32 fps = 12; + void clear_fps() ; + ::uint32_t fps() const; + void set_fps(::uint32_t value); + + private: + ::uint32_t _internal_fps() const; + void _internal_set_fps(::uint32_t value); + + public: + // uint32 gameMode = 13; + void clear_gamemode() ; + ::uint32_t gamemode() const; + void set_gamemode(::uint32_t value); + + private: + ::uint32_t _internal_gamemode() const; + void _internal_set_gamemode(::uint32_t value); + + public: + // uint32 gnDifficulty = 14; + void clear_gndifficulty() ; + ::uint32_t gndifficulty() const; + void set_gndifficulty(::uint32_t value); + + private: + ::uint32_t _internal_gndifficulty() const; + void _internal_set_gndifficulty(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.game.FrameUpdate) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 5, 27, 10, + 59, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const FrameUpdate& from_msg); + ::google::protobuf::RepeatedPtrField< ::dapi::data::TileData > dpiece_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::PlayerData > playerdata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::ItemData > itemdata_; + ::google::protobuf::RepeatedField<::uint32_t> grounditemid_; + ::google::protobuf::internal::CachedSize _grounditemid_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::TownerData > townerdata_; + ::google::protobuf::RepeatedField<::uint32_t> storeoption_; + ::google::protobuf::internal::CachedSize _storeoption_cached_byte_size_; + ::google::protobuf::RepeatedField<::uint32_t> storeitems_; + ::google::protobuf::internal::CachedSize _storeitems_cached_byte_size_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::TriggerData > triggerdata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::MonsterData > monsterdata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::ObjectData > objectdata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::MissileData > missiledata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::PortalData > portaldata_; + ::google::protobuf::RepeatedPtrField< ::dapi::data::QuestData > questdata_; + ::google::protobuf::internal::ArenaStringPtr qtext_; + ::uint32_t player_; + ::int32_t stextflag_; + ::int32_t pausemode_; + ::uint32_t cursor_; + bool menuopen_; + bool chrflag_; + bool invflag_; + bool qtextflag_; + ::uint32_t currlevel_; + bool setlevel_; + ::uint32_t fps_; + ::uint32_t gamemode_; + ::uint32_t gndifficulty_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_game_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// FrameUpdate + +// uint32 player = 1; +inline void FrameUpdate::clear_player() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_ = 0u; +} +inline ::uint32_t FrameUpdate::player() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.player) + return _internal_player(); +} +inline void FrameUpdate::set_player(::uint32_t value) { + _internal_set_player(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.player) +} +inline ::uint32_t FrameUpdate::_internal_player() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.player_; +} +inline void FrameUpdate::_internal_set_player(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.player_ = value; +} + +// sint32 stextflag = 2; +inline void FrameUpdate::clear_stextflag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stextflag_ = 0; +} +inline ::int32_t FrameUpdate::stextflag() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.stextflag) + return _internal_stextflag(); +} +inline void FrameUpdate::set_stextflag(::int32_t value) { + _internal_set_stextflag(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.stextflag) +} +inline ::int32_t FrameUpdate::_internal_stextflag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.stextflag_; +} +inline void FrameUpdate::_internal_set_stextflag(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.stextflag_ = value; +} + +// sint32 pauseMode = 3; +inline void FrameUpdate::clear_pausemode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pausemode_ = 0; +} +inline ::int32_t FrameUpdate::pausemode() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.pauseMode) + return _internal_pausemode(); +} +inline void FrameUpdate::set_pausemode(::int32_t value) { + _internal_set_pausemode(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.pauseMode) +} +inline ::int32_t FrameUpdate::_internal_pausemode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.pausemode_; +} +inline void FrameUpdate::_internal_set_pausemode(::int32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.pausemode_ = value; +} + +// bool menuOpen = 4; +inline void FrameUpdate::clear_menuopen() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.menuopen_ = false; +} +inline bool FrameUpdate::menuopen() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.menuOpen) + return _internal_menuopen(); +} +inline void FrameUpdate::set_menuopen(bool value) { + _internal_set_menuopen(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.menuOpen) +} +inline bool FrameUpdate::_internal_menuopen() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.menuopen_; +} +inline void FrameUpdate::_internal_set_menuopen(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.menuopen_ = value; +} + +// uint32 cursor = 5; +inline void FrameUpdate::clear_cursor() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cursor_ = 0u; +} +inline ::uint32_t FrameUpdate::cursor() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.cursor) + return _internal_cursor(); +} +inline void FrameUpdate::set_cursor(::uint32_t value) { + _internal_set_cursor(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.cursor) +} +inline ::uint32_t FrameUpdate::_internal_cursor() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.cursor_; +} +inline void FrameUpdate::_internal_set_cursor(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.cursor_ = value; +} + +// bool chrflag = 6; +inline void FrameUpdate::clear_chrflag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.chrflag_ = false; +} +inline bool FrameUpdate::chrflag() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.chrflag) + return _internal_chrflag(); +} +inline void FrameUpdate::set_chrflag(bool value) { + _internal_set_chrflag(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.chrflag) +} +inline bool FrameUpdate::_internal_chrflag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.chrflag_; +} +inline void FrameUpdate::_internal_set_chrflag(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.chrflag_ = value; +} + +// bool invflag = 7; +inline void FrameUpdate::clear_invflag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.invflag_ = false; +} +inline bool FrameUpdate::invflag() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.invflag) + return _internal_invflag(); +} +inline void FrameUpdate::set_invflag(bool value) { + _internal_set_invflag(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.invflag) +} +inline bool FrameUpdate::_internal_invflag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.invflag_; +} +inline void FrameUpdate::_internal_set_invflag(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.invflag_ = value; +} + +// bool qtextflag = 8; +inline void FrameUpdate::clear_qtextflag() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtextflag_ = false; +} +inline bool FrameUpdate::qtextflag() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.qtextflag) + return _internal_qtextflag(); +} +inline void FrameUpdate::set_qtextflag(bool value) { + _internal_set_qtextflag(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.qtextflag) +} +inline bool FrameUpdate::_internal_qtextflag() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.qtextflag_; +} +inline void FrameUpdate::_internal_set_qtextflag(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtextflag_ = value; +} + +// string qtext = 9; +inline void FrameUpdate::clear_qtext() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtext_.ClearToEmpty(); +} +inline const std::string& FrameUpdate::qtext() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.qtext) + return _internal_qtext(); +} +template +inline PROTOBUF_ALWAYS_INLINE void FrameUpdate::set_qtext(Arg_&& arg, + Args_... args) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtext_.Set(static_cast(arg), args..., GetArena()); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.qtext) +} +inline std::string* FrameUpdate::mutable_qtext() ABSL_ATTRIBUTE_LIFETIME_BOUND { + std::string* _s = _internal_mutable_qtext(); + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.qtext) + return _s; +} +inline const std::string& FrameUpdate::_internal_qtext() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.qtext_.Get(); +} +inline void FrameUpdate::_internal_set_qtext(const std::string& value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtext_.Set(value, GetArena()); +} +inline std::string* FrameUpdate::_internal_mutable_qtext() { + ::google::protobuf::internal::TSanWrite(&_impl_); + return _impl_.qtext_.Mutable( GetArena()); +} +inline std::string* FrameUpdate::release_qtext() { + ::google::protobuf::internal::TSanWrite(&_impl_); + // @@protoc_insertion_point(field_release:dapi.game.FrameUpdate.qtext) + return _impl_.qtext_.Release(); +} +inline void FrameUpdate::set_allocated_qtext(std::string* value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.qtext_.SetAllocated(value, GetArena()); + if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.qtext_.IsDefault()) { + _impl_.qtext_.Set("", GetArena()); + } + // @@protoc_insertion_point(field_set_allocated:dapi.game.FrameUpdate.qtext) +} + +// uint32 currlevel = 10; +inline void FrameUpdate::clear_currlevel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.currlevel_ = 0u; +} +inline ::uint32_t FrameUpdate::currlevel() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.currlevel) + return _internal_currlevel(); +} +inline void FrameUpdate::set_currlevel(::uint32_t value) { + _internal_set_currlevel(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.currlevel) +} +inline ::uint32_t FrameUpdate::_internal_currlevel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.currlevel_; +} +inline void FrameUpdate::_internal_set_currlevel(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.currlevel_ = value; +} + +// bool setlevel = 11; +inline void FrameUpdate::clear_setlevel() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.setlevel_ = false; +} +inline bool FrameUpdate::setlevel() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.setlevel) + return _internal_setlevel(); +} +inline void FrameUpdate::set_setlevel(bool value) { + _internal_set_setlevel(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.setlevel) +} +inline bool FrameUpdate::_internal_setlevel() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.setlevel_; +} +inline void FrameUpdate::_internal_set_setlevel(bool value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.setlevel_ = value; +} + +// uint32 fps = 12; +inline void FrameUpdate::clear_fps() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.fps_ = 0u; +} +inline ::uint32_t FrameUpdate::fps() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.fps) + return _internal_fps(); +} +inline void FrameUpdate::set_fps(::uint32_t value) { + _internal_set_fps(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.fps) +} +inline ::uint32_t FrameUpdate::_internal_fps() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.fps_; +} +inline void FrameUpdate::_internal_set_fps(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.fps_ = value; +} + +// uint32 gameMode = 13; +inline void FrameUpdate::clear_gamemode() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.gamemode_ = 0u; +} +inline ::uint32_t FrameUpdate::gamemode() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.gameMode) + return _internal_gamemode(); +} +inline void FrameUpdate::set_gamemode(::uint32_t value) { + _internal_set_gamemode(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.gameMode) +} +inline ::uint32_t FrameUpdate::_internal_gamemode() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.gamemode_; +} +inline void FrameUpdate::_internal_set_gamemode(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.gamemode_ = value; +} + +// uint32 gnDifficulty = 14; +inline void FrameUpdate::clear_gndifficulty() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.gndifficulty_ = 0u; +} +inline ::uint32_t FrameUpdate::gndifficulty() const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.gnDifficulty) + return _internal_gndifficulty(); +} +inline void FrameUpdate::set_gndifficulty(::uint32_t value) { + _internal_set_gndifficulty(value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.gnDifficulty) +} +inline ::uint32_t FrameUpdate::_internal_gndifficulty() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.gndifficulty_; +} +inline void FrameUpdate::_internal_set_gndifficulty(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.gndifficulty_ = value; +} + +// repeated .dapi.data.TileData dPiece = 15; +inline int FrameUpdate::_internal_dpiece_size() const { + return _internal_dpiece().size(); +} +inline int FrameUpdate::dpiece_size() const { + return _internal_dpiece_size(); +} +inline ::dapi::data::TileData* FrameUpdate::mutable_dpiece(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.dPiece) + return _internal_mutable_dpiece()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* FrameUpdate::mutable_dpiece() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.dPiece) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_dpiece(); +} +inline const ::dapi::data::TileData& FrameUpdate::dpiece(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.dPiece) + return _internal_dpiece().Get(index); +} +inline ::dapi::data::TileData* FrameUpdate::add_dpiece() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::TileData* _add = _internal_mutable_dpiece()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.dPiece) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& FrameUpdate::dpiece() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.dPiece) + return _internal_dpiece(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& +FrameUpdate::_internal_dpiece() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.dpiece_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* +FrameUpdate::_internal_mutable_dpiece() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.dpiece_; +} + +// repeated .dapi.data.PlayerData playerData = 16; +inline int FrameUpdate::_internal_playerdata_size() const { + return _internal_playerdata().size(); +} +inline int FrameUpdate::playerdata_size() const { + return _internal_playerdata_size(); +} +inline ::dapi::data::PlayerData* FrameUpdate::mutable_playerdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.playerData) + return _internal_mutable_playerdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* FrameUpdate::mutable_playerdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.playerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_playerdata(); +} +inline const ::dapi::data::PlayerData& FrameUpdate::playerdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.playerData) + return _internal_playerdata().Get(index); +} +inline ::dapi::data::PlayerData* FrameUpdate::add_playerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::PlayerData* _add = _internal_mutable_playerdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.playerData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& FrameUpdate::playerdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.playerData) + return _internal_playerdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& +FrameUpdate::_internal_playerdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.playerdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* +FrameUpdate::_internal_mutable_playerdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.playerdata_; +} + +// repeated .dapi.data.ItemData itemData = 17; +inline int FrameUpdate::_internal_itemdata_size() const { + return _internal_itemdata().size(); +} +inline int FrameUpdate::itemdata_size() const { + return _internal_itemdata_size(); +} +inline ::dapi::data::ItemData* FrameUpdate::mutable_itemdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.itemData) + return _internal_mutable_itemdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* FrameUpdate::mutable_itemdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.itemData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_itemdata(); +} +inline const ::dapi::data::ItemData& FrameUpdate::itemdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.itemData) + return _internal_itemdata().Get(index); +} +inline ::dapi::data::ItemData* FrameUpdate::add_itemdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::ItemData* _add = _internal_mutable_itemdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.itemData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& FrameUpdate::itemdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.itemData) + return _internal_itemdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& +FrameUpdate::_internal_itemdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.itemdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* +FrameUpdate::_internal_mutable_itemdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.itemdata_; +} + +// repeated uint32 groundItemID = 18; +inline int FrameUpdate::_internal_grounditemid_size() const { + return _internal_grounditemid().size(); +} +inline int FrameUpdate::grounditemid_size() const { + return _internal_grounditemid_size(); +} +inline void FrameUpdate::clear_grounditemid() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.grounditemid_.Clear(); +} +inline ::uint32_t FrameUpdate::grounditemid(int index) const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.groundItemID) + return _internal_grounditemid().Get(index); +} +inline void FrameUpdate::set_grounditemid(int index, ::uint32_t value) { + _internal_mutable_grounditemid()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.groundItemID) +} +inline void FrameUpdate::add_grounditemid(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_grounditemid()->Add(value); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.groundItemID) +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::grounditemid() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.groundItemID) + return _internal_grounditemid(); +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_grounditemid() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.groundItemID) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_grounditemid(); +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& +FrameUpdate::_internal_grounditemid() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.grounditemid_; +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_grounditemid() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.grounditemid_; +} + +// repeated .dapi.data.TownerData townerData = 19; +inline int FrameUpdate::_internal_townerdata_size() const { + return _internal_townerdata().size(); +} +inline int FrameUpdate::townerdata_size() const { + return _internal_townerdata_size(); +} +inline ::dapi::data::TownerData* FrameUpdate::mutable_townerdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.townerData) + return _internal_mutable_townerdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* FrameUpdate::mutable_townerdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.townerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_townerdata(); +} +inline const ::dapi::data::TownerData& FrameUpdate::townerdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.townerData) + return _internal_townerdata().Get(index); +} +inline ::dapi::data::TownerData* FrameUpdate::add_townerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::TownerData* _add = _internal_mutable_townerdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.townerData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& FrameUpdate::townerdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.townerData) + return _internal_townerdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& +FrameUpdate::_internal_townerdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.townerdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* +FrameUpdate::_internal_mutable_townerdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.townerdata_; +} + +// repeated uint32 storeOption = 20; +inline int FrameUpdate::_internal_storeoption_size() const { + return _internal_storeoption().size(); +} +inline int FrameUpdate::storeoption_size() const { + return _internal_storeoption_size(); +} +inline void FrameUpdate::clear_storeoption() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.storeoption_.Clear(); +} +inline ::uint32_t FrameUpdate::storeoption(int index) const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.storeOption) + return _internal_storeoption().Get(index); +} +inline void FrameUpdate::set_storeoption(int index, ::uint32_t value) { + _internal_mutable_storeoption()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.storeOption) +} +inline void FrameUpdate::add_storeoption(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_storeoption()->Add(value); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.storeOption) +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::storeoption() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.storeOption) + return _internal_storeoption(); +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_storeoption() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.storeOption) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_storeoption(); +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& +FrameUpdate::_internal_storeoption() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.storeoption_; +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_storeoption() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.storeoption_; +} + +// repeated uint32 storeItems = 21; +inline int FrameUpdate::_internal_storeitems_size() const { + return _internal_storeitems().size(); +} +inline int FrameUpdate::storeitems_size() const { + return _internal_storeitems_size(); +} +inline void FrameUpdate::clear_storeitems() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.storeitems_.Clear(); +} +inline ::uint32_t FrameUpdate::storeitems(int index) const { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.storeItems) + return _internal_storeitems().Get(index); +} +inline void FrameUpdate::set_storeitems(int index, ::uint32_t value) { + _internal_mutable_storeitems()->Set(index, value); + // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.storeItems) +} +inline void FrameUpdate::add_storeitems(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _internal_mutable_storeitems()->Add(value); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.storeItems) +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::storeitems() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.storeItems) + return _internal_storeitems(); +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_storeitems() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.storeItems) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_storeitems(); +} +inline const ::google::protobuf::RepeatedField<::uint32_t>& +FrameUpdate::_internal_storeitems() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.storeitems_; +} +inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_storeitems() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.storeitems_; +} + +// repeated .dapi.data.TriggerData triggerData = 22; +inline int FrameUpdate::_internal_triggerdata_size() const { + return _internal_triggerdata().size(); +} +inline int FrameUpdate::triggerdata_size() const { + return _internal_triggerdata_size(); +} +inline ::dapi::data::TriggerData* FrameUpdate::mutable_triggerdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.triggerData) + return _internal_mutable_triggerdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* FrameUpdate::mutable_triggerdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.triggerData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_triggerdata(); +} +inline const ::dapi::data::TriggerData& FrameUpdate::triggerdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.triggerData) + return _internal_triggerdata().Get(index); +} +inline ::dapi::data::TriggerData* FrameUpdate::add_triggerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::TriggerData* _add = _internal_mutable_triggerdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.triggerData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& FrameUpdate::triggerdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.triggerData) + return _internal_triggerdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& +FrameUpdate::_internal_triggerdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.triggerdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* +FrameUpdate::_internal_mutable_triggerdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.triggerdata_; +} + +// repeated .dapi.data.MonsterData monsterData = 23; +inline int FrameUpdate::_internal_monsterdata_size() const { + return _internal_monsterdata().size(); +} +inline int FrameUpdate::monsterdata_size() const { + return _internal_monsterdata_size(); +} +inline ::dapi::data::MonsterData* FrameUpdate::mutable_monsterdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.monsterData) + return _internal_mutable_monsterdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* FrameUpdate::mutable_monsterdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.monsterData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_monsterdata(); +} +inline const ::dapi::data::MonsterData& FrameUpdate::monsterdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.monsterData) + return _internal_monsterdata().Get(index); +} +inline ::dapi::data::MonsterData* FrameUpdate::add_monsterdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::MonsterData* _add = _internal_mutable_monsterdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.monsterData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& FrameUpdate::monsterdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.monsterData) + return _internal_monsterdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& +FrameUpdate::_internal_monsterdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.monsterdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* +FrameUpdate::_internal_mutable_monsterdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.monsterdata_; +} + +// repeated .dapi.data.ObjectData objectData = 24; +inline int FrameUpdate::_internal_objectdata_size() const { + return _internal_objectdata().size(); +} +inline int FrameUpdate::objectdata_size() const { + return _internal_objectdata_size(); +} +inline ::dapi::data::ObjectData* FrameUpdate::mutable_objectdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.objectData) + return _internal_mutable_objectdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* FrameUpdate::mutable_objectdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.objectData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_objectdata(); +} +inline const ::dapi::data::ObjectData& FrameUpdate::objectdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.objectData) + return _internal_objectdata().Get(index); +} +inline ::dapi::data::ObjectData* FrameUpdate::add_objectdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::ObjectData* _add = _internal_mutable_objectdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.objectData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& FrameUpdate::objectdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.objectData) + return _internal_objectdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& +FrameUpdate::_internal_objectdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.objectdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* +FrameUpdate::_internal_mutable_objectdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.objectdata_; +} + +// repeated .dapi.data.MissileData missileData = 25; +inline int FrameUpdate::_internal_missiledata_size() const { + return _internal_missiledata().size(); +} +inline int FrameUpdate::missiledata_size() const { + return _internal_missiledata_size(); +} +inline ::dapi::data::MissileData* FrameUpdate::mutable_missiledata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.missileData) + return _internal_mutable_missiledata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* FrameUpdate::mutable_missiledata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.missileData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_missiledata(); +} +inline const ::dapi::data::MissileData& FrameUpdate::missiledata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.missileData) + return _internal_missiledata().Get(index); +} +inline ::dapi::data::MissileData* FrameUpdate::add_missiledata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::MissileData* _add = _internal_mutable_missiledata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.missileData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& FrameUpdate::missiledata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.missileData) + return _internal_missiledata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& +FrameUpdate::_internal_missiledata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.missiledata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* +FrameUpdate::_internal_mutable_missiledata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.missiledata_; +} + +// repeated .dapi.data.PortalData portalData = 26; +inline int FrameUpdate::_internal_portaldata_size() const { + return _internal_portaldata().size(); +} +inline int FrameUpdate::portaldata_size() const { + return _internal_portaldata_size(); +} +inline ::dapi::data::PortalData* FrameUpdate::mutable_portaldata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.portalData) + return _internal_mutable_portaldata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* FrameUpdate::mutable_portaldata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.portalData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_portaldata(); +} +inline const ::dapi::data::PortalData& FrameUpdate::portaldata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.portalData) + return _internal_portaldata().Get(index); +} +inline ::dapi::data::PortalData* FrameUpdate::add_portaldata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::PortalData* _add = _internal_mutable_portaldata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.portalData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& FrameUpdate::portaldata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.portalData) + return _internal_portaldata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& +FrameUpdate::_internal_portaldata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.portaldata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* +FrameUpdate::_internal_mutable_portaldata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.portaldata_; +} + +// repeated .dapi.data.QuestData questData = 27; +inline int FrameUpdate::_internal_questdata_size() const { + return _internal_questdata().size(); +} +inline int FrameUpdate::questdata_size() const { + return _internal_questdata_size(); +} +inline ::dapi::data::QuestData* FrameUpdate::mutable_questdata(int index) + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.questData) + return _internal_mutable_questdata()->Mutable(index); +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* FrameUpdate::mutable_questdata() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.questData) + ::google::protobuf::internal::TSanWrite(&_impl_); + return _internal_mutable_questdata(); +} +inline const ::dapi::data::QuestData& FrameUpdate::questdata(int index) const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.questData) + return _internal_questdata().Get(index); +} +inline ::dapi::data::QuestData* FrameUpdate::add_questdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::google::protobuf::internal::TSanWrite(&_impl_); + ::dapi::data::QuestData* _add = _internal_mutable_questdata()->Add(); + // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.questData) + return _add; +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& FrameUpdate::questdata() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.questData) + return _internal_questdata(); +} +inline const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& +FrameUpdate::_internal_questdata() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.questdata_; +} +inline ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* +FrameUpdate::_internal_mutable_questdata() { + ::google::protobuf::internal::TSanRead(&_impl_); + return &_impl_.questdata_; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace game +} // namespace dapi + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // game_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/init.pb.cc b/Source/dapi/Backend/Messages/generated/init.pb.cc new file mode 100644 index 000000000..65ad5687d --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/init.pb.cc @@ -0,0 +1,467 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: init.proto +// Protobuf C++ Version: 5.29.3 + +#include "init.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace dapi { +namespace init { + +inline constexpr ServerResponse::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : port_{0u}, + _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ServerResponse::ServerResponse(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ServerResponseDefaultTypeInternal { + PROTOBUF_CONSTEXPR ServerResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ServerResponseDefaultTypeInternal() {} + union { + ServerResponse _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerResponseDefaultTypeInternal _ServerResponse_default_instance_; + +inline constexpr ClientBroadcast::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR ClientBroadcast::ClientBroadcast(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct ClientBroadcastDefaultTypeInternal { + PROTOBUF_CONSTEXPR ClientBroadcastDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~ClientBroadcastDefaultTypeInternal() {} + union { + ClientBroadcast _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientBroadcastDefaultTypeInternal _ClientBroadcast_default_instance_; +} // namespace init +} // namespace dapi +namespace dapi { +namespace init { +// =================================================================== + +class ClientBroadcast::_Internal { + public: +}; + +ClientBroadcast::ClientBroadcast(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.init.ClientBroadcast) +} +ClientBroadcast::ClientBroadcast( + ::google::protobuf::Arena* arena, const ClientBroadcast& from) + : ClientBroadcast(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ClientBroadcast::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ClientBroadcast::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +ClientBroadcast::~ClientBroadcast() { + // @@protoc_insertion_point(destructor:dapi.init.ClientBroadcast) + SharedDtor(*this); +} +inline void ClientBroadcast::SharedDtor(MessageLite& self) { + ClientBroadcast& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ClientBroadcast::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ClientBroadcast(arena); +} +constexpr auto ClientBroadcast::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ClientBroadcast), + alignof(ClientBroadcast)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<26> ClientBroadcast::_class_data_ = { + { + &_ClientBroadcast_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ClientBroadcast::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ClientBroadcast::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ClientBroadcast::ByteSizeLong, + &ClientBroadcast::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ClientBroadcast, _impl_._cached_size_), + true, + }, + "dapi.init.ClientBroadcast", +}; +const ::google::protobuf::internal::ClassData* ClientBroadcast::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ClientBroadcast::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::init::ClientBroadcast>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ClientBroadcast::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.init.ClientBroadcast) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ClientBroadcast::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ClientBroadcast& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ClientBroadcast::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ClientBroadcast& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.init.ClientBroadcast) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.init.ClientBroadcast) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ClientBroadcast::ByteSizeLong(const MessageLite& base) { + const ClientBroadcast& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ClientBroadcast::ByteSizeLong() const { + const ClientBroadcast& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.init.ClientBroadcast) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ClientBroadcast::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.init.ClientBroadcast) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ClientBroadcast::CopyFrom(const ClientBroadcast& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.init.ClientBroadcast) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ClientBroadcast::InternalSwap(ClientBroadcast* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class ServerResponse::_Internal { + public: +}; + +ServerResponse::ServerResponse(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.init.ServerResponse) +} +ServerResponse::ServerResponse( + ::google::protobuf::Arena* arena, const ServerResponse& from) + : ServerResponse(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE ServerResponse::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void ServerResponse::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); + _impl_.port_ = {}; +} +ServerResponse::~ServerResponse() { + // @@protoc_insertion_point(destructor:dapi.init.ServerResponse) + SharedDtor(*this); +} +inline void ServerResponse::SharedDtor(MessageLite& self) { + ServerResponse& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* ServerResponse::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) ServerResponse(arena); +} +constexpr auto ServerResponse::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ServerResponse), + alignof(ServerResponse)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<25> ServerResponse::_class_data_ = { + { + &_ServerResponse_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &ServerResponse::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &ServerResponse::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &ServerResponse::ByteSizeLong, + &ServerResponse::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_._cached_size_), + true, + }, + "dapi.init.ServerResponse", +}; +const ::google::protobuf::internal::ClassData* ServerResponse::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ServerResponse::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 1, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967294, // skipmap + offsetof(decltype(_table_), field_entries), + 1, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::init::ServerResponse>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + // uint32 port = 1; + {::_pbi::TcParser::FastV32S1, + {8, 63, 0, PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_.port_)}}, + }}, {{ + 65535, 65535 + }}, {{ + // uint32 port = 1; + {PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_.port_), 0, 0, + (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, + }}, + // no aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void ServerResponse::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.init.ServerResponse) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _impl_.port_ = 0u; + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* ServerResponse::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const ServerResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* ServerResponse::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const ServerResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.init.ServerResponse) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + // uint32 port = 1; + if (this_._internal_port() != 0) { + target = stream->EnsureSpace(target); + target = ::_pbi::WireFormatLite::WriteUInt32ToArray( + 1, this_._internal_port(), target); + } + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.init.ServerResponse) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t ServerResponse::ByteSizeLong(const MessageLite& base) { + const ServerResponse& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t ServerResponse::ByteSizeLong() const { + const ServerResponse& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.init.ServerResponse) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + { + // uint32 port = 1; + if (this_._internal_port() != 0) { + total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( + this_._internal_port()); + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void ServerResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.init.ServerResponse) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (from._internal_port() != 0) { + _this->_impl_.port_ = from._impl_.port_; + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void ServerResponse::CopyFrom(const ServerResponse& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.init.ServerResponse) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void ServerResponse::InternalSwap(ServerResponse* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.port_, other->_impl_.port_); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace init +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/init.pb.h b/Source/dapi/Backend/Messages/generated/init.pb.h new file mode 100644 index 000000000..2eb3fa885 --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/init.pb.h @@ -0,0 +1,466 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: init.proto +// Protobuf C++ Version: 5.29.3 + +#ifndef init_2eproto_2epb_2eh +#define init_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029003 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_init_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_init_2eproto { + static const ::uint32_t offsets[]; +}; +namespace dapi { +namespace init { +class ClientBroadcast; +struct ClientBroadcastDefaultTypeInternal; +extern ClientBroadcastDefaultTypeInternal _ClientBroadcast_default_instance_; +class ServerResponse; +struct ServerResponseDefaultTypeInternal; +extern ServerResponseDefaultTypeInternal _ServerResponse_default_instance_; +} // namespace init +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace dapi { +namespace init { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class ServerResponse final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.init.ServerResponse) */ { + public: + inline ServerResponse() : ServerResponse(nullptr) {} + ~ServerResponse() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ServerResponse* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ServerResponse)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ServerResponse( + ::google::protobuf::internal::ConstantInitialized); + + inline ServerResponse(const ServerResponse& from) : ServerResponse(nullptr, from) {} + inline ServerResponse(ServerResponse&& from) noexcept + : ServerResponse(nullptr, std::move(from)) {} + inline ServerResponse& operator=(const ServerResponse& from) { + CopyFrom(from); + return *this; + } + inline ServerResponse& operator=(ServerResponse&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ServerResponse& default_instance() { + return *internal_default_instance(); + } + static inline const ServerResponse* internal_default_instance() { + return reinterpret_cast( + &_ServerResponse_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(ServerResponse& a, ServerResponse& b) { a.Swap(&b); } + inline void Swap(ServerResponse* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ServerResponse* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ServerResponse* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ServerResponse& from); + void MergeFrom(const ServerResponse& from) { ServerResponse::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ServerResponse* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.init.ServerResponse"; } + + protected: + explicit ServerResponse(::google::protobuf::Arena* arena); + ServerResponse(::google::protobuf::Arena* arena, const ServerResponse& from); + ServerResponse(::google::protobuf::Arena* arena, ServerResponse&& from) noexcept + : ServerResponse(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kPortFieldNumber = 1, + }; + // uint32 port = 1; + void clear_port() ; + ::uint32_t port() const; + void set_port(::uint32_t value); + + private: + ::uint32_t _internal_port() const; + void _internal_set_port(::uint32_t value); + + public: + // @@protoc_insertion_point(class_scope:dapi.init.ServerResponse) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 1, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ServerResponse& from_msg); + ::uint32_t port_; + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_init_2eproto; +}; +// ------------------------------------------------------------------- + +class ClientBroadcast final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.init.ClientBroadcast) */ { + public: + inline ClientBroadcast() : ClientBroadcast(nullptr) {} + ~ClientBroadcast() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(ClientBroadcast* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(ClientBroadcast)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR ClientBroadcast( + ::google::protobuf::internal::ConstantInitialized); + + inline ClientBroadcast(const ClientBroadcast& from) : ClientBroadcast(nullptr, from) {} + inline ClientBroadcast(ClientBroadcast&& from) noexcept + : ClientBroadcast(nullptr, std::move(from)) {} + inline ClientBroadcast& operator=(const ClientBroadcast& from) { + CopyFrom(from); + return *this; + } + inline ClientBroadcast& operator=(ClientBroadcast&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const ClientBroadcast& default_instance() { + return *internal_default_instance(); + } + static inline const ClientBroadcast* internal_default_instance() { + return reinterpret_cast( + &_ClientBroadcast_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(ClientBroadcast& a, ClientBroadcast& b) { a.Swap(&b); } + inline void Swap(ClientBroadcast* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(ClientBroadcast* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + ClientBroadcast* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const ClientBroadcast& from); + void MergeFrom(const ClientBroadcast& from) { ClientBroadcast::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(ClientBroadcast* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.init.ClientBroadcast"; } + + protected: + explicit ClientBroadcast(::google::protobuf::Arena* arena); + ClientBroadcast(::google::protobuf::Arena* arena, const ClientBroadcast& from); + ClientBroadcast(::google::protobuf::Arena* arena, ClientBroadcast&& from) noexcept + : ClientBroadcast(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.init.ClientBroadcast) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const ClientBroadcast& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_init_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// ClientBroadcast + +// ------------------------------------------------------------------- + +// ServerResponse + +// uint32 port = 1; +inline void ServerResponse::clear_port() { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = 0u; +} +inline ::uint32_t ServerResponse::port() const { + // @@protoc_insertion_point(field_get:dapi.init.ServerResponse.port) + return _internal_port(); +} +inline void ServerResponse::set_port(::uint32_t value) { + _internal_set_port(value); + // @@protoc_insertion_point(field_set:dapi.init.ServerResponse.port) +} +inline ::uint32_t ServerResponse::_internal_port() const { + ::google::protobuf::internal::TSanRead(&_impl_); + return _impl_.port_; +} +inline void ServerResponse::_internal_set_port(::uint32_t value) { + ::google::protobuf::internal::TSanWrite(&_impl_); + _impl_.port_ = value; +} + +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace init +} // namespace dapi + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // init_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/message.pb.cc b/Source/dapi/Backend/Messages/generated/message.pb.cc new file mode 100644 index 000000000..a9c8ad403 --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/message.pb.cc @@ -0,0 +1,818 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: message.proto +// Protobuf C++ Version: 5.29.3 + +#include "message.pb.h" + +#include +#include +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/generated_message_tctable_impl.h" +#include "google/protobuf/extension_set.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/wire_format_lite.h" +#include "google/protobuf/io/zero_copy_stream_impl_lite.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" +PROTOBUF_PRAGMA_INIT_SEG +namespace _pb = ::google::protobuf; +namespace _pbi = ::google::protobuf::internal; +namespace _fl = ::google::protobuf::internal::field_layout; +namespace dapi { +namespace message { + +inline constexpr EndofQueue::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : _cached_size_{0} {} + +template +PROTOBUF_CONSTEXPR EndofQueue::EndofQueue(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct EndofQueueDefaultTypeInternal { + PROTOBUF_CONSTEXPR EndofQueueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~EndofQueueDefaultTypeInternal() {} + union { + EndofQueue _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EndofQueueDefaultTypeInternal _EndofQueue_default_instance_; + +inline constexpr Message::Impl_::Impl_( + ::_pbi::ConstantInitialized) noexcept + : msg_{}, + _cached_size_{0}, + _oneof_case_{} {} + +template +PROTOBUF_CONSTEXPR Message::Message(::_pbi::ConstantInitialized) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(_class_data_.base()), +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(), +#endif // PROTOBUF_CUSTOM_VTABLE + _impl_(::_pbi::ConstantInitialized()) { +} +struct MessageDefaultTypeInternal { + PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} + ~MessageDefaultTypeInternal() {} + union { + Message _instance; + }; +}; + +PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT + PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageDefaultTypeInternal _Message_default_instance_; +} // namespace message +} // namespace dapi +namespace dapi { +namespace message { +// =================================================================== + +class EndofQueue::_Internal { + public: +}; + +EndofQueue::EndofQueue(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.message.EndofQueue) +} +EndofQueue::EndofQueue( + ::google::protobuf::Arena* arena, const EndofQueue& from) + : EndofQueue(arena) { + MergeFrom(from); +} +inline PROTOBUF_NDEBUG_INLINE EndofQueue::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : _cached_size_{0} {} + +inline void EndofQueue::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +EndofQueue::~EndofQueue() { + // @@protoc_insertion_point(destructor:dapi.message.EndofQueue) + SharedDtor(*this); +} +inline void EndofQueue::SharedDtor(MessageLite& self) { + EndofQueue& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + this_._impl_.~Impl_(); +} + +inline void* EndofQueue::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) EndofQueue(arena); +} +constexpr auto EndofQueue::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(EndofQueue), + alignof(EndofQueue)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<24> EndofQueue::_class_data_ = { + { + &_EndofQueue_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &EndofQueue::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &EndofQueue::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &EndofQueue::ByteSizeLong, + &EndofQueue::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(EndofQueue, _impl_._cached_size_), + true, + }, + "dapi.message.EndofQueue", +}; +const ::google::protobuf::internal::ClassData* EndofQueue::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EndofQueue::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 0, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967295, // skipmap + offsetof(decltype(_table_), field_names), // no field_entries + 0, // num_field_entries + 0, // num_aux_entries + offsetof(decltype(_table_), field_names), // no aux_entries + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::message::EndofQueue>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, + // no field_entries, or aux_entries + {{ + }}, +}; + +PROTOBUF_NOINLINE void EndofQueue::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.message.EndofQueue) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* EndofQueue::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const EndofQueue& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* EndofQueue::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const EndofQueue& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.message.EndofQueue) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.message.EndofQueue) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t EndofQueue::ByteSizeLong(const MessageLite& base) { + const EndofQueue& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t EndofQueue::ByteSizeLong() const { + const EndofQueue& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.message.EndofQueue) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void EndofQueue::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.message.EndofQueue) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void EndofQueue::CopyFrom(const EndofQueue& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.message.EndofQueue) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void EndofQueue::InternalSwap(EndofQueue* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); +} + +// =================================================================== + +class Message::_Internal { + public: + static constexpr ::int32_t kOneofCaseOffset = + PROTOBUF_FIELD_OFFSET(::dapi::message::Message, _impl_._oneof_case_); +}; + +void Message::set_allocated_initbroadcast(::dapi::init::ClientBroadcast* initbroadcast) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_msg(); + if (initbroadcast) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(initbroadcast)->GetArena(); + if (message_arena != submessage_arena) { + initbroadcast = ::google::protobuf::internal::GetOwnedMessage(message_arena, initbroadcast, submessage_arena); + } + set_has_initbroadcast(); + _impl_.msg_.initbroadcast_ = initbroadcast; + } + // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.initBroadcast) +} +void Message::clear_initbroadcast() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (msg_case() == kInitBroadcast) { + if (GetArena() == nullptr) { + delete _impl_.msg_.initbroadcast_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.initbroadcast_ != nullptr) { + _impl_.msg_.initbroadcast_->Clear(); + } + } + clear_has_msg(); + } +} +void Message::set_allocated_initresponse(::dapi::init::ServerResponse* initresponse) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_msg(); + if (initresponse) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(initresponse)->GetArena(); + if (message_arena != submessage_arena) { + initresponse = ::google::protobuf::internal::GetOwnedMessage(message_arena, initresponse, submessage_arena); + } + set_has_initresponse(); + _impl_.msg_.initresponse_ = initresponse; + } + // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.initResponse) +} +void Message::clear_initresponse() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (msg_case() == kInitResponse) { + if (GetArena() == nullptr) { + delete _impl_.msg_.initresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.initresponse_ != nullptr) { + _impl_.msg_.initresponse_->Clear(); + } + } + clear_has_msg(); + } +} +void Message::set_allocated_frameupdate(::dapi::game::FrameUpdate* frameupdate) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_msg(); + if (frameupdate) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(frameupdate)->GetArena(); + if (message_arena != submessage_arena) { + frameupdate = ::google::protobuf::internal::GetOwnedMessage(message_arena, frameupdate, submessage_arena); + } + set_has_frameupdate(); + _impl_.msg_.frameupdate_ = frameupdate; + } + // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.frameUpdate) +} +void Message::clear_frameupdate() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (msg_case() == kFrameUpdate) { + if (GetArena() == nullptr) { + delete _impl_.msg_.frameupdate_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.frameupdate_ != nullptr) { + _impl_.msg_.frameupdate_->Clear(); + } + } + clear_has_msg(); + } +} +void Message::set_allocated_command(::dapi::commands::Command* command) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_msg(); + if (command) { + ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(command)->GetArena(); + if (message_arena != submessage_arena) { + command = ::google::protobuf::internal::GetOwnedMessage(message_arena, command, submessage_arena); + } + set_has_command(); + _impl_.msg_.command_ = command; + } + // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.command) +} +void Message::clear_command() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (msg_case() == kCommand) { + if (GetArena() == nullptr) { + delete _impl_.msg_.command_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.command_ != nullptr) { + _impl_.msg_.command_->Clear(); + } + } + clear_has_msg(); + } +} +void Message::set_allocated_endofqueue(::dapi::message::EndofQueue* endofqueue) { + ::google::protobuf::Arena* message_arena = GetArena(); + clear_msg(); + if (endofqueue) { + ::google::protobuf::Arena* submessage_arena = endofqueue->GetArena(); + if (message_arena != submessage_arena) { + endofqueue = ::google::protobuf::internal::GetOwnedMessage(message_arena, endofqueue, submessage_arena); + } + set_has_endofqueue(); + _impl_.msg_.endofqueue_ = endofqueue; + } + // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.endOfQueue) +} +Message::Message(::google::protobuf::Arena* arena) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + SharedCtor(arena); + // @@protoc_insertion_point(arena_constructor:dapi.message.Message) +} +inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, + const Impl_& from, const ::dapi::message::Message& from_msg) + : msg_{}, + _cached_size_{0}, + _oneof_case_{from._oneof_case_[0]} {} + +Message::Message( + ::google::protobuf::Arena* arena, + const Message& from) +#if defined(PROTOBUF_CUSTOM_VTABLE) + : ::google::protobuf::MessageLite(arena, _class_data_.base()) { +#else // PROTOBUF_CUSTOM_VTABLE + : ::google::protobuf::MessageLite(arena) { +#endif // PROTOBUF_CUSTOM_VTABLE + Message* const _this = this; + (void)_this; + _internal_metadata_.MergeFrom( + from._internal_metadata_); + new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); + switch (msg_case()) { + case MSG_NOT_SET: + break; + case kInitBroadcast: + _impl_.msg_.initbroadcast_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ClientBroadcast>(arena, *from._impl_.msg_.initbroadcast_); + break; + case kInitResponse: + _impl_.msg_.initresponse_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ServerResponse>(arena, *from._impl_.msg_.initresponse_); + break; + case kFrameUpdate: + _impl_.msg_.frameupdate_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::game::FrameUpdate>(arena, *from._impl_.msg_.frameupdate_); + break; + case kCommand: + _impl_.msg_.command_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Command>(arena, *from._impl_.msg_.command_); + break; + case kEndOfQueue: + _impl_.msg_.endofqueue_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::message::EndofQueue>(arena, *from._impl_.msg_.endofqueue_); + break; + } + + // @@protoc_insertion_point(copy_constructor:dapi.message.Message) +} +inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( + ::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena) + : msg_{}, + _cached_size_{0}, + _oneof_case_{} {} + +inline void Message::SharedCtor(::_pb::Arena* arena) { + new (&_impl_) Impl_(internal_visibility(), arena); +} +Message::~Message() { + // @@protoc_insertion_point(destructor:dapi.message.Message) + SharedDtor(*this); +} +inline void Message::SharedDtor(MessageLite& self) { + Message& this_ = static_cast(self); + this_._internal_metadata_.Delete(); + ABSL_DCHECK(this_.GetArena() == nullptr); + if (this_.has_msg()) { + this_.clear_msg(); + } + this_._impl_.~Impl_(); +} + +void Message::clear_msg() { +// @@protoc_insertion_point(one_of_clear_start:dapi.message.Message) + ::google::protobuf::internal::TSanWrite(&_impl_); + switch (msg_case()) { + case kInitBroadcast: { + if (GetArena() == nullptr) { + delete _impl_.msg_.initbroadcast_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.initbroadcast_ != nullptr) { + _impl_.msg_.initbroadcast_->Clear(); + } + } + break; + } + case kInitResponse: { + if (GetArena() == nullptr) { + delete _impl_.msg_.initresponse_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.initresponse_ != nullptr) { + _impl_.msg_.initresponse_->Clear(); + } + } + break; + } + case kFrameUpdate: { + if (GetArena() == nullptr) { + delete _impl_.msg_.frameupdate_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.frameupdate_ != nullptr) { + _impl_.msg_.frameupdate_->Clear(); + } + } + break; + } + case kCommand: { + if (GetArena() == nullptr) { + delete _impl_.msg_.command_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.command_ != nullptr) { + _impl_.msg_.command_->Clear(); + } + } + break; + } + case kEndOfQueue: { + if (GetArena() == nullptr) { + delete _impl_.msg_.endofqueue_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.endofqueue_ != nullptr) { + _impl_.msg_.endofqueue_->Clear(); + } + } + break; + } + case MSG_NOT_SET: { + break; + } + } + _impl_._oneof_case_[0] = MSG_NOT_SET; +} + + +inline void* Message::PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena) { + return ::new (mem) Message(arena); +} +constexpr auto Message::InternalNewImpl_() { + return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Message), + alignof(Message)); +} +PROTOBUF_CONSTINIT +PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::google::protobuf::internal::ClassDataLite<21> Message::_class_data_ = { + { + &_Message_default_instance_._instance, + &_table_.header, + nullptr, // OnDemandRegisterArenaDtor + nullptr, // IsInitialized + &Message::MergeImpl, + ::google::protobuf::MessageLite::GetNewImpl(), +#if defined(PROTOBUF_CUSTOM_VTABLE) + &Message::SharedDtor, + ::google::protobuf::MessageLite::GetClearImpl(), &Message::ByteSizeLong, + &Message::_InternalSerialize, +#endif // PROTOBUF_CUSTOM_VTABLE + PROTOBUF_FIELD_OFFSET(Message, _impl_._cached_size_), + true, + }, + "dapi.message.Message", +}; +const ::google::protobuf::internal::ClassData* Message::GetClassData() const { + return _class_data_.base(); +} +PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 +const ::_pbi::TcParseTable<0, 5, 5, 0, 2> Message::_table_ = { + { + 0, // no _has_bits_ + 0, // no _extensions_ + 5, 0, // max_field_number, fast_idx_mask + offsetof(decltype(_table_), field_lookup_table), + 4294967264, // skipmap + offsetof(decltype(_table_), field_entries), + 5, // num_field_entries + 5, // num_aux_entries + offsetof(decltype(_table_), aux_entries), + _class_data_.base(), + nullptr, // post_loop_handler + ::_pbi::TcParser::GenericFallbackLite, // fallback + #ifdef PROTOBUF_PREFETCH_PARSE_TABLE + ::_pbi::TcParser::GetTable<::dapi::message::Message>(), // to_prefetch + #endif // PROTOBUF_PREFETCH_PARSE_TABLE + }, {{ + {::_pbi::TcParser::MiniParse, {}}, + }}, {{ + 65535, 65535 + }}, {{ + // .dapi.init.ClientBroadcast initBroadcast = 1; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.initbroadcast_), _Internal::kOneofCaseOffset + 0, 0, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.init.ServerResponse initResponse = 2; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.initresponse_), _Internal::kOneofCaseOffset + 0, 1, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.game.FrameUpdate frameUpdate = 3; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.frameupdate_), _Internal::kOneofCaseOffset + 0, 2, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.commands.Command command = 4; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.command_), _Internal::kOneofCaseOffset + 0, 3, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + // .dapi.message.EndofQueue endOfQueue = 5; + {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.endofqueue_), _Internal::kOneofCaseOffset + 0, 4, + (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, + }}, {{ + {::_pbi::TcParser::GetTable<::dapi::init::ClientBroadcast>()}, + {::_pbi::TcParser::GetTable<::dapi::init::ServerResponse>()}, + {::_pbi::TcParser::GetTable<::dapi::game::FrameUpdate>()}, + {::_pbi::TcParser::GetTable<::dapi::commands::Command>()}, + {::_pbi::TcParser::GetTable<::dapi::message::EndofQueue>()}, + }}, {{ + }}, +}; + +PROTOBUF_NOINLINE void Message::Clear() { +// @@protoc_insertion_point(message_clear_start:dapi.message.Message) + ::google::protobuf::internal::TSanWrite(&_impl_); + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void) cached_has_bits; + + clear_msg(); + _internal_metadata_.Clear(); +} + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::uint8_t* Message::_InternalSerialize( + const MessageLite& base, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) { + const Message& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::uint8_t* Message::_InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + const Message& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(serialize_to_array_start:dapi.message.Message) + ::uint32_t cached_has_bits = 0; + (void)cached_has_bits; + + switch (this_.msg_case()) { + case kInitBroadcast: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 1, *this_._impl_.msg_.initbroadcast_, this_._impl_.msg_.initbroadcast_->GetCachedSize(), target, + stream); + break; + } + case kInitResponse: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 2, *this_._impl_.msg_.initresponse_, this_._impl_.msg_.initresponse_->GetCachedSize(), target, + stream); + break; + } + case kFrameUpdate: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 3, *this_._impl_.msg_.frameupdate_, this_._impl_.msg_.frameupdate_->GetCachedSize(), target, + stream); + break; + } + case kCommand: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 4, *this_._impl_.msg_.command_, this_._impl_.msg_.command_->GetCachedSize(), target, + stream); + break; + } + case kEndOfQueue: { + target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( + 5, *this_._impl_.msg_.endofqueue_, this_._impl_.msg_.endofqueue_->GetCachedSize(), target, + stream); + break; + } + default: + break; + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + target = stream->WriteRaw( + this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), + static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); + } + // @@protoc_insertion_point(serialize_to_array_end:dapi.message.Message) + return target; + } + +#if defined(PROTOBUF_CUSTOM_VTABLE) + ::size_t Message::ByteSizeLong(const MessageLite& base) { + const Message& this_ = static_cast(base); +#else // PROTOBUF_CUSTOM_VTABLE + ::size_t Message::ByteSizeLong() const { + const Message& this_ = *this; +#endif // PROTOBUF_CUSTOM_VTABLE + // @@protoc_insertion_point(message_byte_size_start:dapi.message.Message) + ::size_t total_size = 0; + + ::uint32_t cached_has_bits = 0; + // Prevent compiler warnings about cached_has_bits being unused + (void)cached_has_bits; + + switch (this_.msg_case()) { + // .dapi.init.ClientBroadcast initBroadcast = 1; + case kInitBroadcast: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.initbroadcast_); + break; + } + // .dapi.init.ServerResponse initResponse = 2; + case kInitResponse: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.initresponse_); + break; + } + // .dapi.game.FrameUpdate frameUpdate = 3; + case kFrameUpdate: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.frameupdate_); + break; + } + // .dapi.commands.Command command = 4; + case kCommand: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.command_); + break; + } + // .dapi.message.EndofQueue endOfQueue = 5; + case kEndOfQueue: { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.endofqueue_); + break; + } + case MSG_NOT_SET: { + break; + } + } + if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { + total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); + } + this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); + return total_size; + } + +void Message::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { + auto* const _this = static_cast(&to_msg); + auto& from = static_cast(from_msg); + ::google::protobuf::Arena* arena = _this->GetArena(); + // @@protoc_insertion_point(class_specific_merge_from_start:dapi.message.Message) + ABSL_DCHECK_NE(&from, _this); + ::uint32_t cached_has_bits = 0; + (void) cached_has_bits; + + if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { + const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; + const bool oneof_needs_init = oneof_to_case != oneof_from_case; + if (oneof_needs_init) { + if (oneof_to_case != 0) { + _this->clear_msg(); + } + _this->_impl_._oneof_case_[0] = oneof_from_case; + } + + switch (oneof_from_case) { + case kInitBroadcast: { + if (oneof_needs_init) { + _this->_impl_.msg_.initbroadcast_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ClientBroadcast>(arena, *from._impl_.msg_.initbroadcast_); + } else { + _this->_impl_.msg_.initbroadcast_->MergeFrom(from._internal_initbroadcast()); + } + break; + } + case kInitResponse: { + if (oneof_needs_init) { + _this->_impl_.msg_.initresponse_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ServerResponse>(arena, *from._impl_.msg_.initresponse_); + } else { + _this->_impl_.msg_.initresponse_->MergeFrom(from._internal_initresponse()); + } + break; + } + case kFrameUpdate: { + if (oneof_needs_init) { + _this->_impl_.msg_.frameupdate_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::game::FrameUpdate>(arena, *from._impl_.msg_.frameupdate_); + } else { + _this->_impl_.msg_.frameupdate_->MergeFrom(from._internal_frameupdate()); + } + break; + } + case kCommand: { + if (oneof_needs_init) { + _this->_impl_.msg_.command_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Command>(arena, *from._impl_.msg_.command_); + } else { + _this->_impl_.msg_.command_->MergeFrom(from._internal_command()); + } + break; + } + case kEndOfQueue: { + if (oneof_needs_init) { + _this->_impl_.msg_.endofqueue_ = + ::google::protobuf::MessageLite::CopyConstruct<::dapi::message::EndofQueue>(arena, *from._impl_.msg_.endofqueue_); + } else { + _this->_impl_.msg_.endofqueue_->MergeFrom(from._internal_endofqueue()); + } + break; + } + case MSG_NOT_SET: + break; + } + } + _this->_internal_metadata_.MergeFrom(from._internal_metadata_); +} + +void Message::CopyFrom(const Message& from) { +// @@protoc_insertion_point(class_specific_copy_from_start:dapi.message.Message) + if (&from == this) return; + Clear(); + MergeFrom(from); +} + + +void Message::InternalSwap(Message* PROTOBUF_RESTRICT other) { + using std::swap; + _internal_metadata_.InternalSwap(&other->_internal_metadata_); + swap(_impl_.msg_, other->_impl_.msg_); + swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); +} + +// @@protoc_insertion_point(namespace_scope) +} // namespace message +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google +// @@protoc_insertion_point(global_scope) +#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/message.pb.h b/Source/dapi/Backend/Messages/generated/message.pb.h new file mode 100644 index 000000000..cea94c880 --- /dev/null +++ b/Source/dapi/Backend/Messages/generated/message.pb.h @@ -0,0 +1,924 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// NO CHECKED-IN PROTOBUF GENCODE +// source: message.proto +// Protobuf C++ Version: 5.29.3 + +#ifndef message_2eproto_2epb_2eh +#define message_2eproto_2epb_2eh + +#include +#include +#include +#include + +#include "google/protobuf/runtime_version.h" +#if PROTOBUF_VERSION != 5029003 +#error "Protobuf C++ gencode is built with an incompatible version of" +#error "Protobuf C++ headers/runtime. See" +#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" +#endif +#include "google/protobuf/io/coded_stream.h" +#include "google/protobuf/arena.h" +#include "google/protobuf/arenastring.h" +#include "google/protobuf/generated_message_tctable_decl.h" +#include "google/protobuf/generated_message_util.h" +#include "google/protobuf/metadata_lite.h" +#include "google/protobuf/message_lite.h" +#include "google/protobuf/repeated_field.h" // IWYU pragma: export +#include "google/protobuf/extension_set.h" // IWYU pragma: export +#include "init.pb.h" +#include "game.pb.h" +#include "command.pb.h" +// @@protoc_insertion_point(includes) + +// Must be included last. +#include "google/protobuf/port_def.inc" + +#define PROTOBUF_INTERNAL_EXPORT_message_2eproto + +namespace google { +namespace protobuf { +namespace internal { +template +::absl::string_view GetAnyMessageName(); +} // namespace internal +} // namespace protobuf +} // namespace google + +// Internal implementation detail -- do not use these members. +struct TableStruct_message_2eproto { + static const ::uint32_t offsets[]; +}; +namespace dapi { +namespace message { +class EndofQueue; +struct EndofQueueDefaultTypeInternal; +extern EndofQueueDefaultTypeInternal _EndofQueue_default_instance_; +class Message; +struct MessageDefaultTypeInternal; +extern MessageDefaultTypeInternal _Message_default_instance_; +} // namespace message +} // namespace dapi +namespace google { +namespace protobuf { +} // namespace protobuf +} // namespace google + +namespace dapi { +namespace message { + +// =================================================================== + + +// ------------------------------------------------------------------- + +class EndofQueue final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.message.EndofQueue) */ { + public: + inline EndofQueue() : EndofQueue(nullptr) {} + ~EndofQueue() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(EndofQueue* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(EndofQueue)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR EndofQueue( + ::google::protobuf::internal::ConstantInitialized); + + inline EndofQueue(const EndofQueue& from) : EndofQueue(nullptr, from) {} + inline EndofQueue(EndofQueue&& from) noexcept + : EndofQueue(nullptr, std::move(from)) {} + inline EndofQueue& operator=(const EndofQueue& from) { + CopyFrom(from); + return *this; + } + inline EndofQueue& operator=(EndofQueue&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const EndofQueue& default_instance() { + return *internal_default_instance(); + } + static inline const EndofQueue* internal_default_instance() { + return reinterpret_cast( + &_EndofQueue_default_instance_); + } + static constexpr int kIndexInFileMessages = 0; + friend void swap(EndofQueue& a, EndofQueue& b) { a.Swap(&b); } + inline void Swap(EndofQueue* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(EndofQueue* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + EndofQueue* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const EndofQueue& from); + void MergeFrom(const EndofQueue& from) { EndofQueue::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(EndofQueue* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.message.EndofQueue"; } + + protected: + explicit EndofQueue(::google::protobuf::Arena* arena); + EndofQueue(::google::protobuf::Arena* arena, const EndofQueue& from); + EndofQueue(::google::protobuf::Arena* arena, EndofQueue&& from) noexcept + : EndofQueue(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<24> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + // @@protoc_insertion_point(class_scope:dapi.message.EndofQueue) + private: + class _Internal; + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 0, 0, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const EndofQueue& from_msg); + ::google::protobuf::internal::CachedSize _cached_size_; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_message_2eproto; +}; +// ------------------------------------------------------------------- + +class Message final : public ::google::protobuf::MessageLite +/* @@protoc_insertion_point(class_definition:dapi.message.Message) */ { + public: + inline Message() : Message(nullptr) {} + ~Message() PROTOBUF_FINAL; + +#if defined(PROTOBUF_CUSTOM_VTABLE) + void operator delete(Message* msg, std::destroying_delete_t) { + SharedDtor(*msg); + ::google::protobuf::internal::SizedDelete(msg, sizeof(Message)); + } +#endif + + template + explicit PROTOBUF_CONSTEXPR Message( + ::google::protobuf::internal::ConstantInitialized); + + inline Message(const Message& from) : Message(nullptr, from) {} + inline Message(Message&& from) noexcept + : Message(nullptr, std::move(from)) {} + inline Message& operator=(const Message& from) { + CopyFrom(from); + return *this; + } + inline Message& operator=(Message&& from) noexcept { + if (this == &from) return *this; + if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { + InternalSwap(&from); + } else { + CopyFrom(from); + } + return *this; + } + + inline const std::string& unknown_fields() const + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); + } + inline std::string* mutable_unknown_fields() + ABSL_ATTRIBUTE_LIFETIME_BOUND { + return _internal_metadata_.mutable_unknown_fields(); + } + + static const Message& default_instance() { + return *internal_default_instance(); + } + enum MsgCase { + kInitBroadcast = 1, + kInitResponse = 2, + kFrameUpdate = 3, + kCommand = 4, + kEndOfQueue = 5, + MSG_NOT_SET = 0, + }; + static inline const Message* internal_default_instance() { + return reinterpret_cast( + &_Message_default_instance_); + } + static constexpr int kIndexInFileMessages = 1; + friend void swap(Message& a, Message& b) { a.Swap(&b); } + inline void Swap(Message* other) { + if (other == this) return; + if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { + InternalSwap(other); + } else { + ::google::protobuf::internal::GenericSwap(this, other); + } + } + void UnsafeArenaSwap(Message* other) { + if (other == this) return; + ABSL_DCHECK(GetArena() == other->GetArena()); + InternalSwap(other); + } + + // implements Message ---------------------------------------------- + + Message* New(::google::protobuf::Arena* arena = nullptr) const { + return ::google::protobuf::MessageLite::DefaultConstruct(arena); + } + void CopyFrom(const Message& from); + void MergeFrom(const Message& from) { Message::MergeImpl(*this, from); } + + private: + static void MergeImpl(::google::protobuf::MessageLite& to_msg, + const ::google::protobuf::MessageLite& from_msg); + + public: + bool IsInitialized() const { + return true; + } + ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; + #if defined(PROTOBUF_CUSTOM_VTABLE) + private: + static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); + static ::uint8_t* _InternalSerialize( + const MessageLite& msg, ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream); + + public: + ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const { + return _InternalSerialize(*this, target, stream); + } + #else // PROTOBUF_CUSTOM_VTABLE + ::size_t ByteSizeLong() const final; + ::uint8_t* _InternalSerialize( + ::uint8_t* target, + ::google::protobuf::io::EpsCopyOutputStream* stream) const final; + #endif // PROTOBUF_CUSTOM_VTABLE + int GetCachedSize() const { return _impl_._cached_size_.Get(); } + + private: + void SharedCtor(::google::protobuf::Arena* arena); + static void SharedDtor(MessageLite& self); + void InternalSwap(Message* other); + private: + template + friend ::absl::string_view( + ::google::protobuf::internal::GetAnyMessageName)(); + static ::absl::string_view FullMessageName() { return "dapi.message.Message"; } + + protected: + explicit Message(::google::protobuf::Arena* arena); + Message(::google::protobuf::Arena* arena, const Message& from); + Message(::google::protobuf::Arena* arena, Message&& from) noexcept + : Message(arena) { + *this = ::std::move(from); + } + const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; + static void* PlacementNew_(const void*, void* mem, + ::google::protobuf::Arena* arena); + static constexpr auto InternalNewImpl_(); + static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; + + public: + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + enum : int { + kInitBroadcastFieldNumber = 1, + kInitResponseFieldNumber = 2, + kFrameUpdateFieldNumber = 3, + kCommandFieldNumber = 4, + kEndOfQueueFieldNumber = 5, + }; + // .dapi.init.ClientBroadcast initBroadcast = 1; + bool has_initbroadcast() const; + private: + bool _internal_has_initbroadcast() const; + + public: + void clear_initbroadcast() ; + const ::dapi::init::ClientBroadcast& initbroadcast() const; + PROTOBUF_NODISCARD ::dapi::init::ClientBroadcast* release_initbroadcast(); + ::dapi::init::ClientBroadcast* mutable_initbroadcast(); + void set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value); + void unsafe_arena_set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value); + ::dapi::init::ClientBroadcast* unsafe_arena_release_initbroadcast(); + + private: + const ::dapi::init::ClientBroadcast& _internal_initbroadcast() const; + ::dapi::init::ClientBroadcast* _internal_mutable_initbroadcast(); + + public: + // .dapi.init.ServerResponse initResponse = 2; + bool has_initresponse() const; + private: + bool _internal_has_initresponse() const; + + public: + void clear_initresponse() ; + const ::dapi::init::ServerResponse& initresponse() const; + PROTOBUF_NODISCARD ::dapi::init::ServerResponse* release_initresponse(); + ::dapi::init::ServerResponse* mutable_initresponse(); + void set_allocated_initresponse(::dapi::init::ServerResponse* value); + void unsafe_arena_set_allocated_initresponse(::dapi::init::ServerResponse* value); + ::dapi::init::ServerResponse* unsafe_arena_release_initresponse(); + + private: + const ::dapi::init::ServerResponse& _internal_initresponse() const; + ::dapi::init::ServerResponse* _internal_mutable_initresponse(); + + public: + // .dapi.game.FrameUpdate frameUpdate = 3; + bool has_frameupdate() const; + private: + bool _internal_has_frameupdate() const; + + public: + void clear_frameupdate() ; + const ::dapi::game::FrameUpdate& frameupdate() const; + PROTOBUF_NODISCARD ::dapi::game::FrameUpdate* release_frameupdate(); + ::dapi::game::FrameUpdate* mutable_frameupdate(); + void set_allocated_frameupdate(::dapi::game::FrameUpdate* value); + void unsafe_arena_set_allocated_frameupdate(::dapi::game::FrameUpdate* value); + ::dapi::game::FrameUpdate* unsafe_arena_release_frameupdate(); + + private: + const ::dapi::game::FrameUpdate& _internal_frameupdate() const; + ::dapi::game::FrameUpdate* _internal_mutable_frameupdate(); + + public: + // .dapi.commands.Command command = 4; + bool has_command() const; + private: + bool _internal_has_command() const; + + public: + void clear_command() ; + const ::dapi::commands::Command& command() const; + PROTOBUF_NODISCARD ::dapi::commands::Command* release_command(); + ::dapi::commands::Command* mutable_command(); + void set_allocated_command(::dapi::commands::Command* value); + void unsafe_arena_set_allocated_command(::dapi::commands::Command* value); + ::dapi::commands::Command* unsafe_arena_release_command(); + + private: + const ::dapi::commands::Command& _internal_command() const; + ::dapi::commands::Command* _internal_mutable_command(); + + public: + // .dapi.message.EndofQueue endOfQueue = 5; + bool has_endofqueue() const; + private: + bool _internal_has_endofqueue() const; + + public: + void clear_endofqueue() ; + const ::dapi::message::EndofQueue& endofqueue() const; + PROTOBUF_NODISCARD ::dapi::message::EndofQueue* release_endofqueue(); + ::dapi::message::EndofQueue* mutable_endofqueue(); + void set_allocated_endofqueue(::dapi::message::EndofQueue* value); + void unsafe_arena_set_allocated_endofqueue(::dapi::message::EndofQueue* value); + ::dapi::message::EndofQueue* unsafe_arena_release_endofqueue(); + + private: + const ::dapi::message::EndofQueue& _internal_endofqueue() const; + ::dapi::message::EndofQueue* _internal_mutable_endofqueue(); + + public: + void clear_msg(); + MsgCase msg_case() const; + // @@protoc_insertion_point(class_scope:dapi.message.Message) + private: + class _Internal; + void set_has_initbroadcast(); + void set_has_initresponse(); + void set_has_frameupdate(); + void set_has_command(); + void set_has_endofqueue(); + inline bool has_msg() const; + inline void clear_has_msg(); + friend class ::google::protobuf::internal::TcParser; + static const ::google::protobuf::internal::TcParseTable< + 0, 5, 5, + 0, 2> + _table_; + + friend class ::google::protobuf::MessageLite; + friend class ::google::protobuf::Arena; + template + friend class ::google::protobuf::Arena::InternalHelper; + using InternalArenaConstructable_ = void; + using DestructorSkippable_ = void; + struct Impl_ { + inline explicit constexpr Impl_( + ::google::protobuf::internal::ConstantInitialized) noexcept; + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena); + inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, + ::google::protobuf::Arena* arena, const Impl_& from, + const Message& from_msg); + union MsgUnion { + constexpr MsgUnion() : _constinit_{} {} + ::google::protobuf::internal::ConstantInitialized _constinit_; + ::dapi::init::ClientBroadcast* initbroadcast_; + ::dapi::init::ServerResponse* initresponse_; + ::dapi::game::FrameUpdate* frameupdate_; + ::dapi::commands::Command* command_; + ::dapi::message::EndofQueue* endofqueue_; + } msg_; + ::google::protobuf::internal::CachedSize _cached_size_; + ::uint32_t _oneof_case_[1]; + PROTOBUF_TSAN_DECLARE_MEMBER + }; + union { Impl_ _impl_; }; + friend struct ::TableStruct_message_2eproto; +}; + +// =================================================================== + + + + +// =================================================================== + + +#ifdef __GNUC__ +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wstrict-aliasing" +#endif // __GNUC__ +// ------------------------------------------------------------------- + +// EndofQueue + +// ------------------------------------------------------------------- + +// Message + +// .dapi.init.ClientBroadcast initBroadcast = 1; +inline bool Message::has_initbroadcast() const { + return msg_case() == kInitBroadcast; +} +inline bool Message::_internal_has_initbroadcast() const { + return msg_case() == kInitBroadcast; +} +inline void Message::set_has_initbroadcast() { + _impl_._oneof_case_[0] = kInitBroadcast; +} +inline ::dapi::init::ClientBroadcast* Message::release_initbroadcast() { + // @@protoc_insertion_point(field_release:dapi.message.Message.initBroadcast) + if (msg_case() == kInitBroadcast) { + clear_has_msg(); + auto* temp = _impl_.msg_.initbroadcast_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.msg_.initbroadcast_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::init::ClientBroadcast& Message::_internal_initbroadcast() const { + return msg_case() == kInitBroadcast ? *_impl_.msg_.initbroadcast_ : reinterpret_cast<::dapi::init::ClientBroadcast&>(::dapi::init::_ClientBroadcast_default_instance_); +} +inline const ::dapi::init::ClientBroadcast& Message::initbroadcast() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.message.Message.initBroadcast) + return _internal_initbroadcast(); +} +inline ::dapi::init::ClientBroadcast* Message::unsafe_arena_release_initbroadcast() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.initBroadcast) + if (msg_case() == kInitBroadcast) { + clear_has_msg(); + auto* temp = _impl_.msg_.initbroadcast_; + _impl_.msg_.initbroadcast_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message::unsafe_arena_set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_msg(); + if (value) { + set_has_initbroadcast(); + _impl_.msg_.initbroadcast_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.initBroadcast) +} +inline ::dapi::init::ClientBroadcast* Message::_internal_mutable_initbroadcast() { + if (msg_case() != kInitBroadcast) { + clear_msg(); + set_has_initbroadcast(); + _impl_.msg_.initbroadcast_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::init::ClientBroadcast>(GetArena()); + } + return _impl_.msg_.initbroadcast_; +} +inline ::dapi::init::ClientBroadcast* Message::mutable_initbroadcast() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::init::ClientBroadcast* _msg = _internal_mutable_initbroadcast(); + // @@protoc_insertion_point(field_mutable:dapi.message.Message.initBroadcast) + return _msg; +} + +// .dapi.init.ServerResponse initResponse = 2; +inline bool Message::has_initresponse() const { + return msg_case() == kInitResponse; +} +inline bool Message::_internal_has_initresponse() const { + return msg_case() == kInitResponse; +} +inline void Message::set_has_initresponse() { + _impl_._oneof_case_[0] = kInitResponse; +} +inline ::dapi::init::ServerResponse* Message::release_initresponse() { + // @@protoc_insertion_point(field_release:dapi.message.Message.initResponse) + if (msg_case() == kInitResponse) { + clear_has_msg(); + auto* temp = _impl_.msg_.initresponse_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.msg_.initresponse_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::init::ServerResponse& Message::_internal_initresponse() const { + return msg_case() == kInitResponse ? *_impl_.msg_.initresponse_ : reinterpret_cast<::dapi::init::ServerResponse&>(::dapi::init::_ServerResponse_default_instance_); +} +inline const ::dapi::init::ServerResponse& Message::initresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.message.Message.initResponse) + return _internal_initresponse(); +} +inline ::dapi::init::ServerResponse* Message::unsafe_arena_release_initresponse() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.initResponse) + if (msg_case() == kInitResponse) { + clear_has_msg(); + auto* temp = _impl_.msg_.initresponse_; + _impl_.msg_.initresponse_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message::unsafe_arena_set_allocated_initresponse(::dapi::init::ServerResponse* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_msg(); + if (value) { + set_has_initresponse(); + _impl_.msg_.initresponse_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.initResponse) +} +inline ::dapi::init::ServerResponse* Message::_internal_mutable_initresponse() { + if (msg_case() != kInitResponse) { + clear_msg(); + set_has_initresponse(); + _impl_.msg_.initresponse_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::init::ServerResponse>(GetArena()); + } + return _impl_.msg_.initresponse_; +} +inline ::dapi::init::ServerResponse* Message::mutable_initresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::init::ServerResponse* _msg = _internal_mutable_initresponse(); + // @@protoc_insertion_point(field_mutable:dapi.message.Message.initResponse) + return _msg; +} + +// .dapi.game.FrameUpdate frameUpdate = 3; +inline bool Message::has_frameupdate() const { + return msg_case() == kFrameUpdate; +} +inline bool Message::_internal_has_frameupdate() const { + return msg_case() == kFrameUpdate; +} +inline void Message::set_has_frameupdate() { + _impl_._oneof_case_[0] = kFrameUpdate; +} +inline ::dapi::game::FrameUpdate* Message::release_frameupdate() { + // @@protoc_insertion_point(field_release:dapi.message.Message.frameUpdate) + if (msg_case() == kFrameUpdate) { + clear_has_msg(); + auto* temp = _impl_.msg_.frameupdate_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.msg_.frameupdate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::game::FrameUpdate& Message::_internal_frameupdate() const { + return msg_case() == kFrameUpdate ? *_impl_.msg_.frameupdate_ : reinterpret_cast<::dapi::game::FrameUpdate&>(::dapi::game::_FrameUpdate_default_instance_); +} +inline const ::dapi::game::FrameUpdate& Message::frameupdate() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.message.Message.frameUpdate) + return _internal_frameupdate(); +} +inline ::dapi::game::FrameUpdate* Message::unsafe_arena_release_frameupdate() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.frameUpdate) + if (msg_case() == kFrameUpdate) { + clear_has_msg(); + auto* temp = _impl_.msg_.frameupdate_; + _impl_.msg_.frameupdate_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message::unsafe_arena_set_allocated_frameupdate(::dapi::game::FrameUpdate* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_msg(); + if (value) { + set_has_frameupdate(); + _impl_.msg_.frameupdate_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.frameUpdate) +} +inline ::dapi::game::FrameUpdate* Message::_internal_mutable_frameupdate() { + if (msg_case() != kFrameUpdate) { + clear_msg(); + set_has_frameupdate(); + _impl_.msg_.frameupdate_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::game::FrameUpdate>(GetArena()); + } + return _impl_.msg_.frameupdate_; +} +inline ::dapi::game::FrameUpdate* Message::mutable_frameupdate() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::game::FrameUpdate* _msg = _internal_mutable_frameupdate(); + // @@protoc_insertion_point(field_mutable:dapi.message.Message.frameUpdate) + return _msg; +} + +// .dapi.commands.Command command = 4; +inline bool Message::has_command() const { + return msg_case() == kCommand; +} +inline bool Message::_internal_has_command() const { + return msg_case() == kCommand; +} +inline void Message::set_has_command() { + _impl_._oneof_case_[0] = kCommand; +} +inline ::dapi::commands::Command* Message::release_command() { + // @@protoc_insertion_point(field_release:dapi.message.Message.command) + if (msg_case() == kCommand) { + clear_has_msg(); + auto* temp = _impl_.msg_.command_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.msg_.command_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::commands::Command& Message::_internal_command() const { + return msg_case() == kCommand ? *_impl_.msg_.command_ : reinterpret_cast<::dapi::commands::Command&>(::dapi::commands::_Command_default_instance_); +} +inline const ::dapi::commands::Command& Message::command() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.message.Message.command) + return _internal_command(); +} +inline ::dapi::commands::Command* Message::unsafe_arena_release_command() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.command) + if (msg_case() == kCommand) { + clear_has_msg(); + auto* temp = _impl_.msg_.command_; + _impl_.msg_.command_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message::unsafe_arena_set_allocated_command(::dapi::commands::Command* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_msg(); + if (value) { + set_has_command(); + _impl_.msg_.command_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.command) +} +inline ::dapi::commands::Command* Message::_internal_mutable_command() { + if (msg_case() != kCommand) { + clear_msg(); + set_has_command(); + _impl_.msg_.command_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Command>(GetArena()); + } + return _impl_.msg_.command_; +} +inline ::dapi::commands::Command* Message::mutable_command() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::commands::Command* _msg = _internal_mutable_command(); + // @@protoc_insertion_point(field_mutable:dapi.message.Message.command) + return _msg; +} + +// .dapi.message.EndofQueue endOfQueue = 5; +inline bool Message::has_endofqueue() const { + return msg_case() == kEndOfQueue; +} +inline bool Message::_internal_has_endofqueue() const { + return msg_case() == kEndOfQueue; +} +inline void Message::set_has_endofqueue() { + _impl_._oneof_case_[0] = kEndOfQueue; +} +inline void Message::clear_endofqueue() { + ::google::protobuf::internal::TSanWrite(&_impl_); + if (msg_case() == kEndOfQueue) { + if (GetArena() == nullptr) { + delete _impl_.msg_.endofqueue_; + } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { + if (_impl_.msg_.endofqueue_ != nullptr) { + _impl_.msg_.endofqueue_->Clear(); + } + } + clear_has_msg(); + } +} +inline ::dapi::message::EndofQueue* Message::release_endofqueue() { + // @@protoc_insertion_point(field_release:dapi.message.Message.endOfQueue) + if (msg_case() == kEndOfQueue) { + clear_has_msg(); + auto* temp = _impl_.msg_.endofqueue_; + if (GetArena() != nullptr) { + temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); + } + _impl_.msg_.endofqueue_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline const ::dapi::message::EndofQueue& Message::_internal_endofqueue() const { + return msg_case() == kEndOfQueue ? *_impl_.msg_.endofqueue_ : reinterpret_cast<::dapi::message::EndofQueue&>(::dapi::message::_EndofQueue_default_instance_); +} +inline const ::dapi::message::EndofQueue& Message::endofqueue() const ABSL_ATTRIBUTE_LIFETIME_BOUND { + // @@protoc_insertion_point(field_get:dapi.message.Message.endOfQueue) + return _internal_endofqueue(); +} +inline ::dapi::message::EndofQueue* Message::unsafe_arena_release_endofqueue() { + // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.endOfQueue) + if (msg_case() == kEndOfQueue) { + clear_has_msg(); + auto* temp = _impl_.msg_.endofqueue_; + _impl_.msg_.endofqueue_ = nullptr; + return temp; + } else { + return nullptr; + } +} +inline void Message::unsafe_arena_set_allocated_endofqueue(::dapi::message::EndofQueue* value) { + // We rely on the oneof clear method to free the earlier contents + // of this oneof. We can directly use the pointer we're given to + // set the new value. + clear_msg(); + if (value) { + set_has_endofqueue(); + _impl_.msg_.endofqueue_ = value; + } + // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.endOfQueue) +} +inline ::dapi::message::EndofQueue* Message::_internal_mutable_endofqueue() { + if (msg_case() != kEndOfQueue) { + clear_msg(); + set_has_endofqueue(); + _impl_.msg_.endofqueue_ = + ::google::protobuf::MessageLite::DefaultConstruct<::dapi::message::EndofQueue>(GetArena()); + } + return _impl_.msg_.endofqueue_; +} +inline ::dapi::message::EndofQueue* Message::mutable_endofqueue() ABSL_ATTRIBUTE_LIFETIME_BOUND { + ::dapi::message::EndofQueue* _msg = _internal_mutable_endofqueue(); + // @@protoc_insertion_point(field_mutable:dapi.message.Message.endOfQueue) + return _msg; +} + +inline bool Message::has_msg() const { + return msg_case() != MSG_NOT_SET; +} +inline void Message::clear_has_msg() { + _impl_._oneof_case_[0] = MSG_NOT_SET; +} +inline Message::MsgCase Message::msg_case() const { + return Message::MsgCase(_impl_._oneof_case_[0]); +} +#ifdef __GNUC__ +#pragma GCC diagnostic pop +#endif // __GNUC__ + +// @@protoc_insertion_point(namespace_scope) +} // namespace message +} // namespace dapi + + +// @@protoc_insertion_point(global_scope) + +#include "google/protobuf/port_undef.inc" + +#endif // message_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/init.proto b/Source/dapi/Backend/Messages/init.proto new file mode 100644 index 000000000..816bb331a --- /dev/null +++ b/Source/dapi/Backend/Messages/init.proto @@ -0,0 +1,12 @@ +syntax = "proto3"; +option optimize_for = LITE_RUNTIME; + +package dapi.init; + +message ClientBroadcast { + +} + +message ServerResponse { + uint32 port = 1; +} diff --git a/Source/dapi/Backend/Messages/message.proto b/Source/dapi/Backend/Messages/message.proto new file mode 100644 index 000000000..77d1efd96 --- /dev/null +++ b/Source/dapi/Backend/Messages/message.proto @@ -0,0 +1,26 @@ +syntax = "proto3"; +option optimize_for = LITE_RUNTIME; +import "init.proto"; +import "game.proto"; +import "command.proto"; + +package dapi.message; + +// Empty message to intidate end of queue +message EndofQueue { + +} + +// Wrapper used to distinguish which message is which +message Message{ + oneof msg { + dapi.init.ClientBroadcast initBroadcast = 1; + dapi.init.ServerResponse initResponse = 2; + + dapi.game.FrameUpdate frameUpdate = 3; + + dapi.commands.Command command = 4; + + EndofQueue endOfQueue = 5; + } +} diff --git a/Source/dapi/DiabloStructs.h b/Source/dapi/DiabloStructs.h new file mode 100644 index 000000000..e69de29bb diff --git a/Source/dapi/GameData.h b/Source/dapi/GameData.h new file mode 100644 index 000000000..5fee30c4c --- /dev/null +++ b/Source/dapi/GameData.h @@ -0,0 +1,47 @@ +#pragma once + +#include +#include + +#include "Item.h" +#include "Player.h" +#include "Towner.h" +#include "Trigger.h" + +namespace DAPI { +enum struct StoreOption { + TALK, + IDENTIFYANITEM, + EXIT, + HEAL, + BUYITEMS, + WIRTPEEK, + BUYBASIC, + BUYPREMIUM, + SELL, + REPAIR, + RECHARGE, + BACK +}; + +struct GameData { + int player; + char stextflag; + int pauseMode; + bool menuOpen; + int pcurs; + bool chrflag; + bool invflag; + bool qtextflag; + int currlevel; + bool setlevel; + + std::map playerList; + std::vector itemList; + std::vector groundItems; + std::vector townerList; + std::vector storeList; + std::vector storeItems; + std::vector triggerList; +}; +} // namespace DAPI diff --git a/Source/dapi/Item.h b/Source/dapi/Item.h new file mode 100644 index 000000000..2dbd26e53 --- /dev/null +++ b/Source/dapi/Item.h @@ -0,0 +1,72 @@ +#pragma once +#include + +#include "../items.h" + +namespace DAPI { +struct ItemData { + bool compare(devilution::Item &item) + { + return item._iSeed == _iSeed && item._iCreateInfo == _iCreateInfo && item.IDidx == IDidx; + } + + int ID; + + int _iSeed; + int _iCreateInfo; + int _itype; + int _ix; + int _iy; + + BOOL _iIdentified; + char _iMagical; + char _iName[64]; + char _iIName[64]; + char _iClass; + int _iCurs; + int _ivalue; + int _iMinDam; + int _iMaxDam; + int _iAC; + int _iFlags; + int _iMiscId; + int _iSpell; + + int _iCharges; + int _iMaxCharges; + + int _iDurability; + int _iMaxDur; + + int _iPLDam; + int _iPLToHit; + int _iPLAC; + int _iPLStr; + int _iPLMag; + int _iPLDex; + int _iPLVit; + int _iPLFR; + int _iPLLR; + int _iPLMR; + int _iPLMana; + int _iPLHP; + int _iPLDamMod; + int _iPLGetHit; + int _iPLLight; + char _iSplLvlAdd; + + int _iFMinDam; + int _iFMaxDam; + int _iLMinDam; + int _iLMaxDam; + + char _iPrePower; + char _iSufPower; + + char _iMinStr; + char _iMinMag; + char _iMinDex; + BOOL _iStatFlag; + int IDidx; +}; +} // namespace DAPI diff --git a/Source/dapi/Player.h b/Source/dapi/Player.h new file mode 100644 index 000000000..911dfc838 --- /dev/null +++ b/Source/dapi/Player.h @@ -0,0 +1,74 @@ +#pragma once +#include "Item.h" + + +namespace DAPI { +const int NUM_INVLOC = 7; +const int MAXINV = 40; +const int MAXSPD = 8; + +struct PlayerData { + int _pmode; + int pnum; + int plrlevel; + int _px; + int _py; + int _pfutx; + int _pfuty; + int _pdir; + + int _pRSpell; + char _pRSplType; + + char _pSplLvl[64]; + unsigned __int64 _pMemSpells; + unsigned __int64 _pAblSpells; + unsigned __int64 _pScrlSpells; + + char _pName[32]; + char _pClass; + + int _pStrength; + int _pBaseStr; + int _pMagic; + int _pBaseMag; + int _pDexterity; + int _pBaseDex; + int _pVitality; + int _pBaseVit; + + int _pStatPts; + + int _pDamageMod; + + int _pHitPoints; + int _pMaxHP; + int _pMana; + int _pMaxMana; + char _pLevel; + int _pExperience; + + char _pArmorClass; + + char _pMagResist; + char _pFireResist; + char _pLightResist; + + int _pGold; + + std::map InvBody; + int InvList[MAXINV]; + int InvGrid[MAXINV]; + std::map SpdList; + int HoldItem; + + int _pIMinDam; + int _pIMaxDam; + int _pIBonusDam; + int _pIAC; + int _pIBonusToHit; + int _pIBonusAC; + int _pIBonusDamMod; + bool pManaShield; +}; +} // namespace DAPI diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp new file mode 100644 index 000000000..7aab6eda6 --- /dev/null +++ b/Source/dapi/Server.cpp @@ -0,0 +1,2437 @@ +#include "Server.h" + + + +namespace DAPI { +Server::Server() + : FPS(20) +{ + output.open("output.csv"); + data = std::make_unique(); + for (int x = -8; x < 9; x++) { + switch (x) { + case 8: + panelScreenCheck[std::make_pair(x, 3)] = true; + break; + case 7: + for (int y = 2; y < 5; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 6: + for (int y = 1; y < 6; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 5: + for (int y = 0; y < 7; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 4: + for (int y = -1; y < 8; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 3: + for (int y = -2; y < 9; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 2: + for (int y = -3; y < 8; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 1: + for (int y = -4; y < 7; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case 0: + for (int y = -5; y < 6; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -1: + for (int y = -6; y < 5; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -2: + for (int y = -7; y < 4; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -3: + for (int y = -8; y < 3; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -4: + for (int y = -7; y < 2; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -5: + for (int y = -6; y < 1; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -6: + for (int y = -5; y < 0; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -7: + for (int y = -4; y < -1; y++) + panelScreenCheck[std::make_pair(x, y)] = true; + break; + case -8: + panelScreenCheck[std::make_pair(x, -3)] = true; + break; + } + } +} + +void Server::update() +{ + if (isConnected()) { + updateGameData(); + protoClient.transmitMessages(); + protoClient.receiveMessages(); + processMessages(); + } else { + checkForConnections(); + } +} + +bool Server::isConnected() const +{ + return protoClient.isConnected(); +} + +void Server::processMessages() +{ + bool issuedCommand = false; + while (protoClient.messageQueueSize()) { + auto message = protoClient.getNextMessage(); + if (message.get() == nullptr) + return; + if (message->has_endofqueue()) + return; + + if (message->has_command() && !issuedCommand) { + auto command = message->command(); + if (command.has_move() && this->OKToAct()) { + auto moveMessage = command.move(); + this->move(moveMessage.targetx(), moveMessage.targety()); + } else if (command.has_talk() && this->OKToAct()) { + auto talkMessage = command.talk(); + this->talk(talkMessage.targetx(), talkMessage.targety()); + } else if (command.has_option() && this->data->stextflag) { + auto option = command.option(); + this->selectStoreOption(static_cast(command.option().option())); + } else if (command.has_buyitem()) { + auto buyItem = command.buyitem(); + this->buyItem(buyItem.id()); + } else if (command.has_sellitem()) { + auto sellItem = command.sellitem(); + this->sellItem(sellItem.id()); + } else if (command.has_rechargeitem()) { + auto rechargeItem = command.rechargeitem(); + this->rechargeItem(rechargeItem.id()); + } else if (command.has_repairitem()) { + auto repairItem = command.repairitem(); + this->repairItem(repairItem.id()); + } else if (command.has_attackmonster()) { + auto attackMonster = command.attackmonster(); + this->attackMonster(attackMonster.index()); + } else if (command.has_attackxy()) { + auto attackXY = command.attackxy(); + this->attackXY(attackXY.x(), attackXY.y()); + } else if (command.has_operateobject()) { + auto operateObject = command.operateobject(); + this->operateObject(operateObject.index()); + } else if (command.has_usebeltitem()) { + auto useBeltItem = command.usebeltitem(); + this->useBeltItem(useBeltItem.slot()); + } else if (command.has_togglecharactersheet()) { + auto toggleCharacterSheet = command.togglecharactersheet(); + this->toggleCharacterScreen(); + } else if (command.has_increasestat()) { + auto increaseStat = command.increasestat(); + this->increaseStat(static_cast(increaseStat.stat())); + } else if (command.has_getitem()) { + auto getItem = command.getitem(); + this->getItem(getItem.id()); + } else if (command.has_setspell()) { + auto setSpell = command.setspell(); + this->setSpell(setSpell.spellid(), static_cast(setSpell.spelltype())); + } else if (command.has_castmonster()) { + auto castMonster = command.castmonster(); + this->castSpell(castMonster.index()); + } else if (command.has_toggleinventory()) { + this->toggleInventory(); + } else if (command.has_putincursor()) { + auto putInCursor = command.putincursor(); + this->putInCursor(putInCursor.id()); + } else if (command.has_putcursoritem()) { + auto putCursorItem = command.putcursoritem(); + this->putCursorItem(putCursorItem.target()); + } else if (command.has_dropcursoritem()) { + this->dropCursorItem(); + } else if (command.has_useitem()) { + auto useItem = command.useitem(); + this->useItem(useItem.id()); + } else if (command.has_identifystoreitem()) { + auto identifyStoreItem = command.identifystoreitem(); + this->identifyStoreItem(identifyStoreItem.id()); + } else if (command.has_castxy()) { + auto castXY = command.castxy(); + this->castSpell(castXY.x(), castXY.y()); + } else if (command.has_cancelqtext()) { + this->cancelQText(); + } else if (command.has_disarmtrap()) { + auto disarmTrap = command.disarmtrap(); + this->disarmTrap(disarmTrap.index()); + } else if (command.has_skillrepair()) { + auto skillRepair = command.skillrepair(); + this->skillRepair(skillRepair.id()); + } else if (command.has_skillrecharge()) { + auto skillRecharge = command.skillrecharge(); + this->skillRecharge(skillRecharge.id()); + } else if (command.has_togglemenu()) { + this->toggleMenu(); + } else if (command.has_savegame()) { + this->saveGame(); + } else if (command.has_quit()) { + this->quit(); + } else if (command.has_clearcursor()) { + this->clearCursor(); + } else if (command.has_identifyitem()) { + auto identifyItem = command.identifyitem(); + this->identifyItem(identifyItem.id()); + } + issuedCommand = true; + if (command.has_setfps()) { + auto setfps = command.setfps(); + this->setFPS(setfps.fps()); + issuedCommand = false; + } + } + } +} + +void Server::checkForConnections() +{ + if (isConnected()) + return; + if (!listening) { + protoClient.initListen(); + listening = false; + } + protoClient.checkForConnection(); + if (!protoClient.isConnected()) + return; + protoClient.stopListen(); +} + +void Server::updateGameData() +{ + std::vector itemsModified; + + auto fullFillItemInfo = [&](int itemID, devilution::Item *item) { + itemsModified.push_back(itemID); + + data->itemList[itemID].ID = itemID; + data->itemList[itemID]._iSeed = item->_iSeed; + data->itemList[itemID]._iCreateInfo = item->_iCreateInfo; + data->itemList[itemID]._itype = static_cast(item->_itype); + data->itemList[itemID]._ix = item->position.x; + data->itemList[itemID]._iy = item->position.y; + + data->itemList[itemID]._iIdentified = item->_iIdentified; + data->itemList[itemID]._iMagical = item->_iMagical; + strcpy_s(data->itemList[itemID]._iName, item->_iName); + if (data->itemList[itemID]._iIdentified) { + strcpy_s(data->itemList[itemID]._iIName, item->_iIName); + + data->itemList[itemID]._iFlags = static_cast(item->_iFlags); + data->itemList[itemID]._iPrePower = item->_iPrePower; + data->itemList[itemID]._iSufPower = item->_iSufPower; + data->itemList[itemID]._iPLDam = item->_iPLDam; + data->itemList[itemID]._iPLToHit = item->_iPLToHit; + data->itemList[itemID]._iPLAC = item->_iPLAC; + data->itemList[itemID]._iPLStr = item->_iPLStr; + data->itemList[itemID]._iPLMag = item->_iPLMag; + data->itemList[itemID]._iPLDex = item->_iPLDex; + data->itemList[itemID]._iPLVit = item->_iPLVit; + data->itemList[itemID]._iPLFR = item->_iPLFR; + data->itemList[itemID]._iPLLR = item->_iPLLR; + data->itemList[itemID]._iPLMR = item->_iPLMR; + data->itemList[itemID]._iPLMana = item->_iPLMana; + data->itemList[itemID]._iPLHP = item->_iPLHP; + data->itemList[itemID]._iPLDamMod = item->_iPLDamMod; + data->itemList[itemID]._iPLGetHit = item->_iPLGetHit; + data->itemList[itemID]._iPLLight = item->_iPLLight; + data->itemList[itemID]._iSplLvlAdd = item->_iSplLvlAdd; + data->itemList[itemID]._iFMinDam = item->_iFMinDam; + data->itemList[itemID]._iFMaxDam = item->_iFMaxDam; + data->itemList[itemID]._iLMinDam = item->_iLMinDam; + data->itemList[itemID]._iLMaxDam = item->_iLMaxDam; + } else { + strcpy_s(data->itemList[itemID]._iName, item->_iName); + + data->itemList[itemID]._iFlags = -1; + data->itemList[itemID]._iPrePower = -1; + data->itemList[itemID]._iSufPower = -1; + data->itemList[itemID]._iPLDam = -1; + data->itemList[itemID]._iPLToHit = -1; + data->itemList[itemID]._iPLAC = -1; + data->itemList[itemID]._iPLStr = -1; + data->itemList[itemID]._iPLMag = -1; + data->itemList[itemID]._iPLDex = -1; + data->itemList[itemID]._iPLVit = -1; + data->itemList[itemID]._iPLFR = -1; + data->itemList[itemID]._iPLLR = -1; + data->itemList[itemID]._iPLMR = -1; + data->itemList[itemID]._iPLMana = -1; + data->itemList[itemID]._iPLHP = -1; + data->itemList[itemID]._iPLDamMod = -1; + data->itemList[itemID]._iPLGetHit = -1; + data->itemList[itemID]._iPLLight = -1; + data->itemList[itemID]._iSplLvlAdd = -1; + data->itemList[itemID]._iFMinDam = -1; + data->itemList[itemID]._iFMaxDam = -1; + data->itemList[itemID]._iLMinDam = -1; + data->itemList[itemID]._iLMaxDam = -1; + } + data->itemList[itemID]._iClass = item->_iClass; + data->itemList[itemID]._iCurs = item->_iCurs; + if (item->_itype == devilution::ItemType::Gold) + data->itemList[itemID]._ivalue = item->_ivalue; + else + data->itemList[itemID]._ivalue = -1; + data->itemList[itemID]._iMinDam = item->_iMinDam; + data->itemList[itemID]._iMaxDam = item->_iMaxDam; + data->itemList[itemID]._iAC = item->_iAC; + data->itemList[itemID]._iMiscId = item->_iMiscId; + data->itemList[itemID]._iSpell = static_cast(item->_iSpell); + + data->itemList[itemID]._iCharges = item->_iCharges; + data->itemList[itemID]._iMaxCharges = item->_iMaxCharges; + + data->itemList[itemID]._iDurability = item->_iDurability; + data->itemList[itemID]._iMaxDur = item->_iMaxDur; + + data->itemList[itemID]._iMinStr = item->_iMinStr; + data->itemList[itemID]._iMinMag = item->_iMinMag; + data->itemList[itemID]._iMinDex = item->_iMinDex; + data->itemList[itemID]._iStatFlag = item->_iStatFlag; + data->itemList[itemID].IDidx = item->IDidx; + }; + + auto partialFillItemInfo = [&](int itemID, devilution::Item *item) { + itemsModified.push_back(itemID); + + data->itemList[itemID].ID = itemID; + data->itemList[itemID]._iSeed = item->_iSeed; + data->itemList[itemID]._iCreateInfo = item->_iCreateInfo; + data->itemList[itemID]._itype = static_cast(item->_itype); + data->itemList[itemID]._ix = item->position.x; + data->itemList[itemID]._iy = item->position.y; + + data->itemList[itemID]._iIdentified = item->_iIdentified; + data->itemList[itemID]._iMagical = item->_iMagical; + strcpy_s(data->itemList[itemID]._iName, item->_iName); + if (data->itemList[itemID]._iIdentified) + strcpy_s(data->itemList[itemID]._iIName, item->_iIName); + else + strcpy_s(data->itemList[itemID]._iName, item->_iName); + data->itemList[itemID]._iFlags = -1; + data->itemList[itemID]._iPrePower = -1; + data->itemList[itemID]._iSufPower = -1; + data->itemList[itemID]._iPLDam = -1; + data->itemList[itemID]._iPLToHit = -1; + data->itemList[itemID]._iPLAC = -1; + data->itemList[itemID]._iPLStr = -1; + data->itemList[itemID]._iPLMag = -1; + data->itemList[itemID]._iPLDex = -1; + data->itemList[itemID]._iPLVit = -1; + data->itemList[itemID]._iPLFR = -1; + data->itemList[itemID]._iPLLR = -1; + data->itemList[itemID]._iPLMR = -1; + data->itemList[itemID]._iPLMana = -1; + data->itemList[itemID]._iPLHP = -1; + data->itemList[itemID]._iPLDamMod = -1; + data->itemList[itemID]._iPLGetHit = -1; + data->itemList[itemID]._iPLLight = -1; + data->itemList[itemID]._iSplLvlAdd = -1; + data->itemList[itemID]._iFMinDam = -1; + data->itemList[itemID]._iFMaxDam = -1; + data->itemList[itemID]._iLMinDam = -1; + data->itemList[itemID]._iLMaxDam = -1; + data->itemList[itemID]._iClass = item->_iClass; + data->itemList[itemID]._iCurs = item->_iCurs; + if (item->_itype == devilution::ItemType::Gold) + data->itemList[itemID]._ivalue = item->_ivalue; + else + data->itemList[itemID]._ivalue = -1; + data->itemList[itemID]._iMinDam = -1; + data->itemList[itemID]._iMaxDam = -1; + data->itemList[itemID]._iAC = -1; + data->itemList[itemID]._iMiscId = item->_iMiscId; + data->itemList[itemID]._iSpell = static_cast(item->_iSpell); + + data->itemList[itemID]._iCharges = -1; + data->itemList[itemID]._iMaxCharges = -1; + + data->itemList[itemID]._iDurability = -1; + data->itemList[itemID]._iMaxDur = -1; + + data->itemList[itemID]._iMinStr = -1; + data->itemList[itemID]._iMinMag = -1; + data->itemList[itemID]._iMinDex = -1; + data->itemList[itemID]._iStatFlag = -1; + data->itemList[itemID].IDidx = item->IDidx; + }; + + auto isOnScreen = [&](int x, int y) { + int dx = devilution::Players[devilution::MyPlayerId].position.tile.x - x; + int dy = devilution::Players[devilution::MyPlayerId].position.tile.y - y; + if (!devilution::CharFlag && !devilution::invflag) { + if (dy > 0) { + if (dx < 1 && abs(dx) + abs(dy) < 11) { + return true; + } else if (dx > 0 && abs(dx) + abs(dy) < 12) { + return true; + } + } else { + if ((dx > -1 || dy == 0) && abs(dx) + abs(dy) < 11) { + return true; + } else if ((dx < 0 && dy != 0) && abs(dx) + abs(dy) < 12) { + return true; + } + } + } else if ((devilution::CharFlag && !devilution::invflag) || (!devilution::CharFlag && devilution::invflag)) { + return panelScreenCheck[std::make_pair(dx, dy)]; + } + return false; + }; + + auto message = std::make_unique(); + auto update = message->mutable_frameupdate(); + + data->player = devilution::MyPlayerId; + update->set_player(data->player); + + data->stextflag = static_cast(devilution::ActiveStore); + update->set_stextflag(data->stextflag); + data->pauseMode = devilution::PauseMode; + update->set_pausemode(data->pauseMode); + if (devilution::sgpCurrentMenu != nullptr) + data->menuOpen = true; + else + data->menuOpen = false; + update->set_menuopen(data->menuOpen); + data->pcurs = devilution::pcurs; + update->set_cursor(devilution::pcurs); + data->chrflag = devilution::CharFlag; + update->set_chrflag(devilution::CharFlag); + data->invflag = devilution::invflag; + update->set_invflag(devilution::invflag); + data->qtextflag = devilution::qtextflag; + update->set_qtextflag(devilution::qtextflag); + if (!devilution::setlevel) + data->currlevel = static_cast(devilution::currlevel); + else + data->currlevel = static_cast(devilution::setlvlnum); + update->set_currlevel(data->currlevel); + data->setlevel = static_cast(devilution::setlevel); + update->set_setlevel(devilution::setlevel); + if (devilution::qtextflag) { + std::stringstream qtextss; + for (auto &line : devilution::TextLines) + qtextss << line; + update->set_qtext(qtextss.str().c_str()); + } + else + update->set_qtext(""); + update->set_fps(FPS); + if (!devilution::gbIsMultiplayer) + update->set_gamemode(0); + else + update->set_gamemode(1); + + update->set_gndifficulty(devilution::sgGameInitInfo.nDifficulty); + + int range = 10; + if (devilution::MyPlayer->isWalking()) { + range = 11; + } + + for (int x = 0; x < 112; x++) { + for (int y = 0; y < 112; y++) { + if (isOnScreen(x, y)) { + auto dpiece = update->add_dpiece(); + dpiece->set_type(devilution::dPiece[x][y]); + dpiece->set_solid(HasAnyOf(devilution::SOLData[dpiece->type()], devilution::TileProperties::Solid)); + dpiece->set_x(x); + dpiece->set_y(y); + dpiece->set_stopmissile(HasAnyOf(devilution::SOLData[dpiece->type()], devilution::TileProperties::BlockMissile)); + } + } + } + + for (int i = 0; i < devilution::numtrigs; i++) { + if (isOnScreen(devilution::trigs[i].position.x, devilution::trigs[i].position.y)) { + auto trigger = update->add_triggerdata(); + trigger->set_lvl(devilution::trigs[i]._tlvl); + trigger->set_x(devilution::trigs[i].position.x); + trigger->set_y(devilution::trigs[i].position.y); + trigger->set_type(devilution::trigs[i]._tmsg); + } + } + + for (int i = 0; i < MAXQUESTS; i++) { + auto quest = update->add_questdata(); + quest->set_id(i); + if (devilution::Quests[i]._qactive == 2) + quest->set_state(devilution::Quests[i]._qactive); + else + quest->set_state(0); + + if (devilution::currlevel == devilution::Quests[i]._qlevel && devilution::Quests[i]._qslvl != 0 && devilution::Quests[i]._qactive != devilution::quest_state::QUEST_NOTAVAIL) { + auto trigger = update->add_triggerdata(); + trigger->set_lvl(devilution::Quests[i]._qslvl); + trigger->set_x(devilution::Quests[i].position.x); + trigger->set_y(devilution::Quests[i].position.y); + trigger->set_type(1029); + } + } + + data->storeList.clear(); + if (devilution::ActiveStore != devilution::TalkID::None) { + for (int i = 0; i < 24; i++) { + if (devilution::TextLine[i].isSelectable()) { + if (!strcmp(devilution::TextLine[i].text.c_str(), "Talk to Cain") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Farnham") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Pepin") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Gillian") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Ogden") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Griswold") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Adria") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Wirt")) + data->storeList.push_back(StoreOption::TALK); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Identify an item")) + data->storeList.push_back(StoreOption::IDENTIFYANITEM); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Say goodbye") || !strcmp(devilution::TextLine[i].text.c_str(), "Say Goodbye") || !strcmp(devilution::TextLine[i].text.c_str(), "Leave Healer's home") || !strcmp(devilution::TextLine[i].text.c_str(), "Leave the shop") || !strcmp(devilution::TextLine[i].text.c_str(), "Leave the shack") || !strcmp(devilution::TextLine[i].text.c_str(), "Leave the tavern") || !strcmp(devilution::TextLine[i].text.c_str(), "Leave")) + data->storeList.push_back(StoreOption::EXIT); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Receive healing")) + data->storeList.push_back(StoreOption::HEAL); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Buy items")) + data->storeList.push_back(StoreOption::BUYITEMS); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "What have you got?")) + data->storeList.push_back(StoreOption::WIRTPEEK); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Buy basic items")) + data->storeList.push_back(StoreOption::BUYBASIC); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Buy premium items")) + data->storeList.push_back(StoreOption::BUYPREMIUM); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Sell items")) + data->storeList.push_back(StoreOption::SELL); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Repair items")) + data->storeList.push_back(StoreOption::REPAIR); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Recharge staves")) + data->storeList.push_back(StoreOption::RECHARGE); + } + } + + switch (devilution::ActiveStore) { + case devilution::TalkID::HealerBuy: + case devilution::TalkID::StorytellerIdentifyShow: + case devilution::TalkID::NoMoney: + case devilution::TalkID::NoRoom: + case devilution::TalkID::SmithBuy: + case devilution::TalkID::StorytellerIdentify: + case devilution::TalkID::SmithPremiumBuy: + case devilution::TalkID::SmithRepair: + case devilution::TalkID::SmithSell: + case devilution::TalkID::WitchBuy: + case devilution::TalkID::WitchRecharge: + case devilution::TalkID::WitchSell: + case devilution::TalkID::Gossip: + data->storeList.push_back(StoreOption::BACK); + break; + default: + break; + } + } + + for (auto &option : data->storeList) + update->add_storeoption(static_cast(option)); + + data->groundItems.clear(); + + for (int i = 0; i < 4; i++) { + auto playerData = update->add_playerdata(); + + data->playerList[i].InvBody.clear(); + + data->playerList[i].pnum = i; + playerData->set_pnum(i); + + memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); + playerData->set__pname(data->playerList[i]._pName); + + for (int j = 0; j < MAXINV; j++) + data->playerList[i].InvList[j] = -1; + + if (devilution::MyPlayerId == i) { + data->playerList[i]._pmode = devilution::Players[i]._pmode; + data->playerList[i].plrlevel = devilution::Players[i].plrlevel; + data->playerList[i]._px = devilution::Players[i].position.tile.x; + data->playerList[i]._py = devilution::Players[i].position.tile.y; + data->playerList[i]._pfutx = devilution::Players[i].position.future.x; + data->playerList[i]._pfuty = devilution::Players[i].position.future.y; + data->playerList[i]._pdir = static_cast(devilution::Players[i]._pdir); + + data->playerList[i]._pRSpell = static_cast(devilution::Players[i]._pRSpell); + data->playerList[i]._pRSplType = static_cast(devilution::Players[i]._pRSplType); + + memcpy(data->playerList[i]._pSplLvl, devilution::Players[i]._pSplLvl, sizeof(data->playerList[i]._pSplLvl)); + data->playerList[i]._pMemSpells = devilution::Players[i]._pMemSpells; + data->playerList[i]._pAblSpells = devilution::Players[i]._pAblSpells; + data->playerList[i]._pScrlSpells = devilution::Players[i]._pScrlSpells; + + data->playerList[i]._pClass = static_cast(devilution::Players[i]._pClass); + + data->playerList[i]._pStrength = devilution::Players[i]._pStrength; + data->playerList[i]._pBaseStr = devilution::Players[i]._pBaseStr; + data->playerList[i]._pMagic = devilution::Players[i]._pMagic; + data->playerList[i]._pBaseMag = devilution::Players[i]._pBaseMag; + data->playerList[i]._pDexterity = devilution::Players[i]._pDexterity; + data->playerList[i]._pBaseDex = devilution::Players[i]._pBaseDex; + data->playerList[i]._pVitality = devilution::Players[i]._pVitality; + data->playerList[i]._pBaseVit = devilution::Players[i]._pBaseVit; + + data->playerList[i]._pStatPts = devilution::Players[i]._pStatPts; + + data->playerList[i]._pDamageMod = devilution::Players[i]._pDamageMod; + + data->playerList[i]._pHitPoints = devilution::Players[i]._pHitPoints; + data->playerList[i]._pMaxHP = devilution::Players[i]._pMaxHP; + data->playerList[i]._pMana = devilution::Players[i]._pMana; + data->playerList[i]._pMaxMana = devilution::Players[i]._pMaxMana; + data->playerList[i]._pLevel = devilution::Players[i].getCharacterLevel(); + data->playerList[i]._pExperience = devilution::Players[i]._pExperience; + + data->playerList[i]._pArmorClass = devilution::Players[i]._pArmorClass; + + data->playerList[i]._pMagResist = devilution::Players[i]._pMagResist; + data->playerList[i]._pFireResist = devilution::Players[i]._pFireResist; + data->playerList[i]._pLightResist = devilution::Players[i]._pLghtResist; + + data->playerList[i]._pGold = devilution::Players[i]._pGold; + + for (int j = 0; j < NUM_INVLOC; j++) { + if (devilution::Players[i].InvBody[j]._itype == devilution::ItemType::None) { + data->playerList[i].InvBody[j] = -1; + continue; + } + + int itemID = static_cast(data->itemList.size()); + for (int k = 0; k < data->itemList.size(); k++) { + if (data->itemList[k].compare(devilution::Players[i].InvBody[j])) { + itemID = k; + break; + } + } + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + fullFillItemInfo(itemID, &devilution::Players[i].InvBody[j]); + data->playerList[i].InvBody[j] = itemID; + } + bool used[40] = { false }; + for (int j = 0; j < MAXINV; j++) { + auto index = devilution::Players[i].InvGrid[j]; + if (index != 0) { + int itemID = static_cast(data->itemList.size()); + for (int k = 0; k < data->itemList.size(); k++) { + if (data->itemList[k].compare(devilution::Players[i].InvList[abs(index) - 1])) { + itemID = k; + break; + } + } + data->playerList[i].InvGrid[j] = itemID; + if (!used[abs(index) - 1]) { + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + fullFillItemInfo(itemID, &devilution::Players[i].InvList[abs(index) - 1]); + used[abs(index) - 1] = true; + data->playerList[i].InvList[abs(index) - 1] = itemID; + } + } else + data->playerList[i].InvGrid[j] = -1; + } + for (int j = 0; j < MAXSPD; j++) { + if (devilution::Players[i].SpdList[j]._itype == devilution::ItemType::None) { + data->playerList[i].SpdList[j] = -1; + continue; + } + + int itemID = static_cast(data->itemList.size()); + for (int k = 0; k < data->itemList.size(); k++) { + if (data->itemList[k].compare(devilution::Players[i].SpdList[j])) { + itemID = k; + break; + } + } + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + fullFillItemInfo(itemID, &devilution::Players[i].SpdList[j]); + data->playerList[i].SpdList[j] = itemID; + } + if (devilution::pcurs < 12) + data->playerList[i].HoldItem = -1; + else { + int itemID = static_cast(data->itemList.size()); + for (int j = 0; j < data->itemList.size(); j++) { + if (data->itemList[j].compare(devilution::Players[i].HoldItem)) { + itemID = j; + break; + } + } + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + partialFillItemInfo(itemID, &devilution::Players[i].HoldItem); + data->playerList[i].HoldItem = itemID; + } + + data->playerList[i]._pIMinDam = devilution::Players[i]._pIMinDam; + data->playerList[i]._pIMaxDam = devilution::Players[i]._pIMaxDam; + data->playerList[i]._pIBonusDam = devilution::Players[i]._pIBonusDam; + data->playerList[i]._pIAC = devilution::Players[i]._pIAC; + data->playerList[i]._pIBonusToHit = devilution::Players[i]._pIBonusToHit; + data->playerList[i]._pIBonusAC = devilution::Players[i]._pIBonusAC; + data->playerList[i]._pIBonusDamMod = devilution::Players[i]._pIBonusDamMod; + data->playerList[i].pManaShield = devilution::Players[i].pManaShield; + } else if (devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { + data->playerList[i]._pmode = devilution::Players[i]._pmode; + data->playerList[i].plrlevel = devilution::Players[i].plrlevel; + data->playerList[i]._px = devilution::Players[i].position.tile.x; + data->playerList[i]._py = devilution::Players[i].position.tile.y; + data->playerList[i]._pfutx = devilution::Players[i].position.future.x; + data->playerList[i]._pfuty = devilution::Players[i].position.future.y; + data->playerList[i]._pdir = static_cast(devilution::Players[i]._pdir); + + data->playerList[i]._pRSpell = -1; + data->playerList[i]._pRSplType = 4; + + memset(data->playerList[i]._pSplLvl, 0, 64); + data->playerList[i]._pMemSpells = -1; + data->playerList[i]._pAblSpells = -1; + data->playerList[i]._pScrlSpells = -1; + + data->playerList[i]._pClass = static_cast(devilution::Players[i]._pClass); + + data->playerList[i]._pStrength = -1; + data->playerList[i]._pBaseStr = -1; + data->playerList[i]._pMagic = -1; + data->playerList[i]._pBaseMag = -1; + data->playerList[i]._pDexterity = -1; + data->playerList[i]._pBaseDex = -1; + data->playerList[i]._pVitality = -1; + data->playerList[i]._pBaseVit = -1; + + data->playerList[i]._pStatPts = -1; + + data->playerList[i]._pDamageMod = -1; + + data->playerList[i]._pHitPoints = devilution::Players[i]._pHitPoints; + data->playerList[i]._pMaxHP = devilution::Players[i]._pMaxHP; + data->playerList[i]._pMana = -1; + data->playerList[i]._pMaxMana = -1; + data->playerList[i]._pLevel = devilution::Players[i].getCharacterLevel(); + data->playerList[i]._pExperience = -1; + + data->playerList[i]._pArmorClass = -1; + + data->playerList[i]._pMagResist = -1; + data->playerList[i]._pFireResist = -1; + data->playerList[i]._pLightResist = -1; + + data->playerList[i]._pGold = -1; + + for (int j = 0; j < NUM_INVLOC; j++) + data->playerList[i].InvBody[j] = -1; + for (int j = 0; j < MAXINV; j++) + data->playerList[i].InvGrid[j] = -1; + for (int j = 0; j < MAXSPD; j++) + data->playerList[i].SpdList[j] = -1; + data->playerList[i].HoldItem = -1; + + data->playerList[i]._pIMinDam = -1; + data->playerList[i]._pIMaxDam = -1; + data->playerList[i]._pIBonusDam = -1; + data->playerList[i]._pIAC = -1; + data->playerList[i]._pIBonusToHit = -1; + data->playerList[i]._pIBonusAC = -1; + data->playerList[i]._pIBonusDamMod = -1; + data->playerList[i].pManaShield = devilution::Players[i].pManaShield; + } else { + data->playerList[i]._pmode = 0; + data->playerList[i].plrlevel = -1; + data->playerList[i]._px = -1; + data->playerList[i]._py = -1; + data->playerList[i]._pfutx = -1; + data->playerList[i]._pfuty = -1; + data->playerList[i]._pdir = -1; + + data->playerList[i]._pRSpell = -1; + data->playerList[i]._pRSplType = -1; + + memset(data->playerList[i]._pSplLvl, 0, 64); + data->playerList[i]._pMemSpells = -1; + data->playerList[i]._pAblSpells = -1; + data->playerList[i]._pScrlSpells = -1; + + data->playerList[i]._pClass = -1; + + data->playerList[i]._pStrength = -1; + data->playerList[i]._pBaseStr = -1; + data->playerList[i]._pMagic = -1; + data->playerList[i]._pBaseMag = -1; + data->playerList[i]._pDexterity = -1; + data->playerList[i]._pBaseDex = -1; + data->playerList[i]._pVitality = -1; + data->playerList[i]._pBaseVit = -1; + + data->playerList[i]._pStatPts = -1; + + data->playerList[i]._pDamageMod = -1; + + data->playerList[i]._pHitPoints = -1; + data->playerList[i]._pMaxHP = -1; + data->playerList[i]._pMana = -1; + data->playerList[i]._pMaxMana = -1; + data->playerList[i]._pLevel = devilution::Players[i].getCharacterLevel(); + data->playerList[i]._pExperience = -1; + + data->playerList[i]._pArmorClass = -1; + + data->playerList[i]._pMagResist = -1; + data->playerList[i]._pFireResist = -1; + data->playerList[i]._pLightResist = -1; + data->playerList[i]._pIBonusToHit = -1; + + data->playerList[i]._pGold = -1; + for (int j = 0; j < NUM_INVLOC; j++) + data->playerList[i].InvBody[j] = -1; + for (int j = 0; j < MAXINV; j++) + data->playerList[i].InvGrid[j] = -1; + for (int j = 0; j < MAXSPD; j++) + data->playerList[i].SpdList[j] = -1; + data->playerList[i].HoldItem = -1; + + data->playerList[i]._pIMinDam = -1; + data->playerList[i]._pIMaxDam = -1; + data->playerList[i]._pIBonusDam = -1; + data->playerList[i]._pIAC = -1; + data->playerList[i]._pIBonusToHit = -1; + data->playerList[i]._pIBonusAC = -1; + data->playerList[i]._pIBonusDamMod = -1; + data->playerList[i].pManaShield = false; + } + + playerData->set__pmode(data->playerList[i]._pmode); + playerData->set_plrlevel(data->playerList[i].plrlevel); + playerData->set__px(data->playerList[i]._px); + playerData->set__py(data->playerList[i]._py); + playerData->set__pfutx(data->playerList[i]._pfutx); + playerData->set__pfuty(data->playerList[i]._pfuty); + playerData->set__pdir(data->playerList[i]._pdir); + + playerData->set__prspell(data->playerList[i]._pRSpell); + playerData->set__prspltype(data->playerList[i]._pRSplType); + + for (int j = 0; j < 64; j++) + playerData->add__pspllvl(data->playerList[i]._pSplLvl[j]); + playerData->set__pmemspells(data->playerList[i]._pMemSpells); + playerData->set__pablspells(data->playerList[i]._pAblSpells); + playerData->set__pscrlspells(data->playerList[i]._pScrlSpells); + + playerData->set__pclass(data->playerList[i]._pClass); + + playerData->set__pstrength(data->playerList[i]._pStrength); + playerData->set__pbasestr(data->playerList[i]._pBaseStr); + playerData->set__pmagic(data->playerList[i]._pMagic); + playerData->set__pbasemag(data->playerList[i]._pBaseMag); + playerData->set__pdexterity(data->playerList[i]._pDexterity); + playerData->set__pbasedex(data->playerList[i]._pBaseDex); + playerData->set__pvitality(data->playerList[i]._pVitality); + playerData->set__pbasevit(data->playerList[i]._pBaseVit); + + playerData->set__pstatpts(data->playerList[i]._pStatPts); + + playerData->set__pdamagemod(data->playerList[i]._pDamageMod); + + playerData->set__phitpoints(data->playerList[i]._pHitPoints); + playerData->set__pmaxhp(data->playerList[i]._pMaxHP); + playerData->set__pmana(data->playerList[i]._pMana); + playerData->set__pmaxmana(data->playerList[i]._pMaxMana); + playerData->set__plevel(data->playerList[i]._pLevel); + playerData->set__pexperience(data->playerList[i]._pExperience); + + playerData->set__parmorclass(data->playerList[i]._pArmorClass); + + playerData->set__pmagresist(data->playerList[i]._pMagResist); + playerData->set__pfireresist(data->playerList[i]._pFireResist); + playerData->set__plightresist(data->playerList[i]._pLightResist); + + playerData->set__pgold(data->playerList[i]._pGold); + for (int j = 0; j < NUM_INVLOC; j++) + playerData->add_invbody(data->playerList[i].InvBody[j]); + for (int j = 0; j < MAXINV; j++) + playerData->add_invlist(data->playerList[i].InvList[j]); + for (int j = 0; j < MAXINV; j++) + playerData->add_invgrid(data->playerList[i].InvGrid[j]); + for (int j = 0; j < MAXSPD; j++) + playerData->add_spdlist(data->playerList[i].SpdList[j]); + playerData->set_holditem(data->playerList[i].HoldItem); + + playerData->set__pimindam(data->playerList[i]._pIMinDam); + playerData->set__pimaxdam(data->playerList[i]._pIMaxDam); + playerData->set__pibonusdam(data->playerList[i]._pIBonusDam); + playerData->set__piac(data->playerList[i]._pIAC); + playerData->set__pibonustohit(data->playerList[i]._pIBonusToHit); + playerData->set__pibonusac(data->playerList[i]._pIBonusAC); + playerData->set__pibonusdammod(data->playerList[i]._pIBonusDamMod); + playerData->set_pmanashield(data->playerList[i].pManaShield); + } + + auto emptyFillItemInfo = [&](int itemID, devilution::Item *item) { + itemsModified.push_back(itemID); + + data->itemList[itemID].ID = itemID; + data->itemList[itemID]._iSeed = item->_iSeed; + data->itemList[itemID]._iCreateInfo = item->_iCreateInfo; + data->itemList[itemID]._itype = static_cast(item->_itype); + data->itemList[itemID]._ix = -1; + data->itemList[itemID]._iy = -1; + + data->itemList[itemID]._iIdentified = -1; + data->itemList[itemID]._iMagical = -1; + strcpy_s(data->itemList[itemID]._iName, ""); + strcpy_s(data->itemList[itemID]._iIName, ""); + data->itemList[itemID]._iFlags = -1; + data->itemList[itemID]._iPrePower = -1; + data->itemList[itemID]._iSufPower = -1; + data->itemList[itemID]._iPLDam = -1; + data->itemList[itemID]._iPLToHit = -1; + data->itemList[itemID]._iPLAC = -1; + data->itemList[itemID]._iPLStr = -1; + data->itemList[itemID]._iPLMag = -1; + data->itemList[itemID]._iPLDex = -1; + data->itemList[itemID]._iPLVit = -1; + data->itemList[itemID]._iPLFR = -1; + data->itemList[itemID]._iPLLR = -1; + data->itemList[itemID]._iPLMR = -1; + data->itemList[itemID]._iPLMana = -1; + data->itemList[itemID]._iPLHP = -1; + data->itemList[itemID]._iPLDamMod = -1; + data->itemList[itemID]._iPLGetHit = -1; + data->itemList[itemID]._iPLLight = -1; + data->itemList[itemID]._iSplLvlAdd = -1; + data->itemList[itemID]._iFMinDam = -1; + data->itemList[itemID]._iFMaxDam = -1; + data->itemList[itemID]._iLMinDam = -1; + data->itemList[itemID]._iLMaxDam = -1; + data->itemList[itemID]._iClass = -1; + data->itemList[itemID]._ivalue = -1; + data->itemList[itemID]._iMinDam = -1; + data->itemList[itemID]._iMaxDam = -1; + data->itemList[itemID]._iAC = -1; + data->itemList[itemID]._iMiscId = -1; + data->itemList[itemID]._iSpell = -1; + + data->itemList[itemID]._iCharges = -1; + data->itemList[itemID]._iMaxCharges = -1; + + data->itemList[itemID]._iDurability = -1; + data->itemList[itemID]._iMaxDur = -1; + + data->itemList[itemID]._iMinStr = -1; + data->itemList[itemID]._iMinMag = -1; + data->itemList[itemID]._iMinDex = -1; + data->itemList[itemID]._iStatFlag = -1; + data->itemList[itemID].IDidx = item->IDidx; + }; + + for (int i = 0; i < devilution::ActiveItemCount; i++) { + int itemID = static_cast(data->itemList.size()); + for (int j = 0; j < data->itemList.size(); j++) { + if (data->itemList[j].compare(devilution::Items[devilution::ActiveItems[i]])) { + itemID = j; + break; + } + } + + if (devilution::dItem[devilution::Items[devilution::ActiveItems[i]].position.x][devilution::Items[devilution::ActiveItems[i]].position.y] != static_cast(devilution::ActiveItems[i] + 1)) + continue; + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + int dx = devilution::Players[devilution::MyPlayerId].position.tile.x - devilution::Items[devilution::ActiveItems[i]].position.x; + int dy = devilution::Players[devilution::MyPlayerId].position.tile.y - devilution::Items[devilution::ActiveItems[i]].position.y; + if (dy > 0) { + if (dx < 1 && abs(dx) + abs(dy) < 11) { + partialFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + data->groundItems.push_back(itemID); + } else if (dx > 0 && abs(dx) + abs(dy) < 12) { + partialFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + data->groundItems.push_back(itemID); + } else + emptyFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + } else { + if ((dx > -1 || dy == 0) && abs(dx) + abs(dy) < 11) { + partialFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + data->groundItems.push_back(itemID); + } else if ((dx < 0 && dy != 0) && abs(dx) + abs(dy) < 12) { + partialFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + data->groundItems.push_back(itemID); + } else + emptyFillItemInfo(itemID, &devilution::Items[devilution::ActiveItems[i]]); + } + } + + data->storeItems.clear(); + int storeLoopMax = 0; + devilution::Item *currentItem; + bool useiValue = false; + bool shiftValue = false; + switch (devilution::ActiveStore) { + case devilution::TalkID::StorytellerIdentify: + case devilution::TalkID::WitchSell: + case devilution::TalkID::WitchRecharge: + case devilution::TalkID::SmithSell: + case devilution::TalkID::SmithRepair: + storeLoopMax = 48; + currentItem = &devilution::PlayerItems[0]; + useiValue = true; + break; + case devilution::TalkID::WitchBuy: + storeLoopMax = devilution::NumWitchItemsHf; + currentItem = &devilution::WitchItems[0]; + break; + case devilution::TalkID::SmithBuy: + storeLoopMax = devilution::NumSmithBasicItemsHf; + currentItem = &devilution::SmithItems[0]; + useiValue = true; + break; + case devilution::TalkID::HealerBuy: + storeLoopMax = devilution::NumHealerItemsHf; + currentItem = &devilution::HealerItems[0]; + useiValue = true; + break; + case devilution::TalkID::SmithPremiumBuy: + storeLoopMax = devilution::NumSmithItemsHf; + currentItem = &devilution::PremiumItems[0]; + break; + case devilution::TalkID::BoyBuy: + storeLoopMax = 1; + currentItem = &devilution::BoyItem; + shiftValue = true; + break; + } + for (int i = 0; i < storeLoopMax; i++) { + if (currentItem->_itype != devilution::ItemType::None) { + int itemID = static_cast(data->itemList.size()); + + for (auto &item : data->itemList) { + if (item.compare(*currentItem)) { + itemID = item.ID; + break; + } + } + if (itemID == static_cast(data->itemList.size())) { + data->itemList.push_back(ItemData {}); + fullFillItemInfo(itemID, currentItem); + } + if (useiValue) + data->itemList[itemID]._ivalue = currentItem->_ivalue; + else if (shiftValue) + data->itemList[itemID]._ivalue = currentItem->_iIvalue + (currentItem->_iIvalue >> 1); + else + data->itemList[itemID]._ivalue = currentItem->_iIvalue; + if (data->itemList[itemID]._ivalue != 0) { + data->storeItems.push_back(itemID); + update->add_storeitems(itemID); + } + } + currentItem++; + } + + if (devilution::currlevel != 0) { + for (auto &townerData : data->townerList) { + strcpy_s(townerData._tName, ""); + townerData._tx = -1; + townerData._ty = -1; + } + } else { + for (auto i = 0; i < NUM_TOWNERS; i++) { + auto townerID = data->townerList.size(); + for (int j = 0; j < data->townerList.size(); j++) { + if (data->townerList[j]._ttype == devilution::Towners[i]._ttype) { + townerID = j; + break; + } + } + if (townerID == data->townerList.size()) + data->townerList.push_back(TownerData {}); + data->townerList[townerID].ID = static_cast(townerID); + if (isOnScreen(devilution::Towners[i].position.x, devilution::Towners[i].position.y)) { + data->townerList[townerID]._ttype = devilution::Towners[i]._ttype; + data->townerList[townerID]._tx = devilution::Towners[i].position.x; + data->townerList[townerID]._ty = devilution::Towners[i].position.y; + // might rework this and just change the type in data. + if (devilution::Towners[i].name.size() < 31) { + memcpy(data->townerList[townerID]._tName, devilution::Towners[i].name.data(), devilution::Towners[i].name.size()); + data->townerList[townerID]._tName[devilution::Towners[i].name.size()] = '\0'; + } + // strcpy_s(data->townerList[townerID]._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. + } else { + data->townerList[townerID]._ttype = static_cast(devilution::Towners[i]._ttype); + data->townerList[townerID]._tx = -1; + data->townerList[townerID]._ty = -1; + strcpy_s(data->townerList[townerID]._tName, ""); + } + } + } + + for (auto &townie : data->townerList) { + auto townerData = update->add_townerdata(); + townerData->set_id(townie.ID); + if (townie._tx != -1) + townerData->set__ttype(static_cast(townie._ttype)); + else + townerData->set__ttype(-1); + townerData->set__tx(townie._tx); + townerData->set__ty(townie._ty); + townerData->set__tname(townie._tName); + } + + for (auto &itemID : itemsModified) + // for (auto& item : data->itemList) + { + auto &item = data->itemList[itemID]; + auto itemData = update->add_itemdata(); + itemData->set_id(item.ID); + itemData->set__itype(item._itype); + itemData->set__ix(item._ix); + itemData->set__iy(item._iy); + itemData->set__iidentified(item._iIdentified); + itemData->set__imagical(item._iMagical); + itemData->set__iname(item._iName); + itemData->set__iiname(item._iIName); + itemData->set__iclass(item._iClass); + itemData->set__icurs(item._iCurs); + itemData->set__ivalue(item._ivalue); + itemData->set__imindam(item._iMinDam); + itemData->set__imaxdam(item._iMaxDam); + itemData->set__iac(item._iAC); + itemData->set__iflags(item._iFlags); + itemData->set__imiscid(item._iMiscId); + itemData->set__ispell(item._iSpell); + itemData->set__icharges(item._iCharges); + itemData->set__imaxcharges(item._iMaxCharges); + itemData->set__idurability(item._iDurability); + itemData->set__imaxdur(item._iMaxDur); + itemData->set__ipldam(item._iPLDam); + itemData->set__ipltohit(item._iPLToHit); + itemData->set__iplac(item._iPLAC); + itemData->set__iplstr(item._iPLStr); + itemData->set__iplmag(item._iPLMag); + itemData->set__ipldex(item._iPLDex); + itemData->set__iplvit(item._iPLVit); + itemData->set__iplfr(item._iPLFR); + itemData->set__ipllr(item._iPLLR); + itemData->set__iplmr(item._iPLMR); + itemData->set__iplmana(item._iPLMana); + itemData->set__iplhp(item._iPLHP); + itemData->set__ipldammod(item._iPLDamMod); + itemData->set__iplgethit(item._iPLGetHit); + itemData->set__ipllight(item._iPLLight); + itemData->set__ispllvladd(item._iSplLvlAdd); + itemData->set__ifmindam(item._iFMinDam); + itemData->set__ifmaxdam(item._iFMaxDam); + itemData->set__ilmindam(item._iLMinDam); + itemData->set__ilmaxdam(item._iLMaxDam); + itemData->set__iprepower(item._iPrePower); + itemData->set__isufpower(item._iSufPower); + itemData->set__iminstr(item._iMinStr); + itemData->set__iminmag(item._iMinMag); + itemData->set__imindex(item._iMinDex); + itemData->set__istatflag(item._iStatFlag); + itemData->set_ididx(item.IDidx); + } + for (auto &itemID : data->groundItems) + update->add_grounditemid(itemID); + + for (int i = 0; i < devilution::ActiveMonsterCount; i++) { + if (isOnScreen(devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.x, devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.y) && devilution::HasAnyOf(devilution::dFlags[devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.x][devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.y], devilution::DungeonFlag::Lit) && !(devilution::Monsters[devilution::ActiveMonsters[i]].flags & 0x01)) { + auto m = update->add_monsterdata(); + m->set_index(devilution::ActiveMonsters[i]); + m->set_x(devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.x); + m->set_y(devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.y); + m->set_futx(devilution::Monsters[devilution::ActiveMonsters[i]].position.future.x); + m->set_futy(devilution::Monsters[devilution::ActiveMonsters[i]].position.future.y); + m->set_type(devilution::Monsters[devilution::ActiveMonsters[i]].type().type); + m->set_name(devilution::Monsters[devilution::ActiveMonsters[i]].data().name.c_str()); + m->set_mode(static_cast(devilution::Monsters[devilution::ActiveMonsters[i]].mode)); + m->set_unique(static_cast(devilution::Monsters[devilution::ActiveMonsters[i]].isUnique())); + } + } + + auto fillObject = [&](int index, devilution::Object &ob) { + auto o = update->add_objectdata(); + o->set_type(ob._otype); + o->set_x(ob.position.x); + o->set_y(ob.position.y); + o->set_shrinetype(-1); + o->set_solid(ob._oSolidFlag); + o->set_doorstate(-1); + o->set_selectable(ob.selectionRegion != devilution::SelectionRegion::None ? true : false); + o->set_index(index); + switch (static_cast(ob._otype)) { + case devilution::_object_id::OBJ_BARRELEX: + o->set_type(static_cast(devilution::_object_id::OBJ_BARREL)); + break; + case devilution::_object_id::OBJ_SHRINEL: + case devilution::_object_id::OBJ_SHRINER: + if (ob.selectionRegion != devilution::SelectionRegion::None) + o->set_shrinetype(ob._oVar1); + break; + case devilution::_object_id::OBJ_L1LDOOR: + case devilution::_object_id::OBJ_L1RDOOR: + case devilution::_object_id::OBJ_L2LDOOR: + case devilution::_object_id::OBJ_L2RDOOR: + case devilution::_object_id::OBJ_L3LDOOR: + case devilution::_object_id::OBJ_L3RDOOR: + o->set_doorstate(ob._oVar4); + break; + } + if (devilution::Players[devilution::MyPlayerId]._pClass == devilution::HeroClass::Rogue) + o->set_trapped(ob._oTrapFlag); + else + o->set_trapped(false); + }; + + auto fillMissile = [&](devilution::Missile &ms) { + auto m = update->add_missiledata(); + m->set_type(static_cast(ms._mitype)); + m->set_x(ms.position.tile.x); + m->set_y(ms.position.tile.y); + m->set_xvel(ms.position.velocity.deltaX); + m->set_yvel(ms.position.velocity.deltaY); + bool addSource = false; + switch (ms.sourceType()) { + case devilution::MissileSource::Monster: + if (isOnScreen(ms.sourceMonster()->position.tile.x, ms.sourceMonster()->position.tile.y)) { + m->set_sx(ms.sourceMonster()->position.tile.x); + m->set_sy(ms.sourceMonster()->position.tile.y); + } else { + m->set_sx(-1); + m->set_sy(-1); + } + break; + case devilution::MissileSource::Player: + if (isOnScreen(ms.sourcePlayer()->position.tile.x, ms.sourcePlayer()->position.tile.y)) { + m->set_sx(ms.sourcePlayer()->position.tile.x); + m->set_sy(ms.sourcePlayer()->position.tile.y); + } else { + m->set_sx(-1); + m->set_sy(-1); + } + break; + default: + m->set_sx(-1); + m->set_sy(-1); + } + }; + + if (devilution::Players[devilution::MyPlayerId].plrlevel != 0) { + for (int i = 0; i < devilution::ActiveObjectCount; i++) { + if (isOnScreen(devilution::Objects[devilution::ActiveObjects[i]].position.x, devilution::Objects[devilution::ActiveObjects[i]].position.y) && devilution::dObject[devilution::Objects[devilution::ActiveObjects[i]].position.x][devilution::Objects[devilution::ActiveObjects[i]].position.y] == devilution::ActiveObjects[i] + 1) { + fillObject(devilution::ActiveObjects[i], devilution::Objects[devilution::ActiveObjects[i]]); + } + } + + for (auto& missile : devilution::Missiles) { + if (isOnScreen(missile.position.tile.x, missile.position.tile.y)) + fillMissile(missile); + } + } + + for (int i = 0; i < MAXPORTAL; i++) { + if (devilution::Portals[i].open && (devilution::Portals[i].level == devilution::Players[devilution::MyPlayerId].plrlevel) && isOnScreen(devilution::Portals[i].position.x, devilution::Portals[i].position.y)) { + auto tp = update->add_portaldata(); + tp->set_x(devilution::Portals[i].position.x); + tp->set_y(devilution::Portals[i].position.y); + tp->set_player(i); + } else if (devilution::Portals[i].open && 0 == devilution::Players[devilution::MyPlayerId].plrlevel && isOnScreen(devilution::PortalTownPosition[i].x, devilution::PortalTownPosition[i].y)) { + auto tp = update->add_portaldata(); + tp->set_x(devilution::PortalTownPosition[i].x); + tp->set_y(devilution::PortalTownPosition[i].y); + tp->set_player(i); + } + } + + protoClient.queueMessage(std::move(message)); +} + +bool Server::isOnScreen(int x, int y) +{ + bool returnValue = false; + int dx = data->playerList[data->player]._px - x; + int dy = data->playerList[data->player]._py - y; + if (!devilution::CharFlag) { + if (dy > 0) { + if (dx < 1 && abs(dx) + abs(dy) < 11) + returnValue = true; + else if (dx > 0 && abs(dx) + abs(dy) < 12) + returnValue = true; + } else { + if ((dx > -1 || dy == 0) && abs(dx) + abs(dy) < 11) + returnValue = true; + else if ((dx < 0 && dy != 0) && abs(dx) + abs(dy) < 12) + returnValue = true; + } + } else if (devilution::CharFlag) { + returnValue = panelScreenCheck[std::make_pair(dx, dy)]; + } + return returnValue; +} + +bool Server::OKToAct() +{ + return !data->stextflag && data->pcurs == 1 && !data->qtextflag; +} + +void Server::move(int x, int y) +{ + devilution::NetSendCmdLoc(devilution::MyPlayerId, true, devilution::_cmd_id::CMD_WALKXY, devilution::Point { x, y }); +} + +void Server::talk(int x, int y) +{ + int index; + for (index = 0; index < NUM_TOWNERS; index++) { + if (devilution::Towners[index].position.x == x && devilution::Towners[index].position.y == y) + break; + } + if (index != NUM_TOWNERS) + devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_TALKXY, devilution::Point { x, y }, index); +} + +void Server::selectStoreOption(StoreOption option) +{ + switch (option) { + case StoreOption::TALK: + switch (devilution::ActiveStore) { + case devilution::TalkID::Witch: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::OldTextLine = 12; + devilution::TownerId = devilution::_talker_id::TOWN_WITCH; + devilution::OldActiveStore = devilution::TalkID::Witch; + devilution::StartStore(devilution::TalkID::Gossip); + break; + } + case StoreOption::IDENTIFYANITEM: + if (devilution::ActiveStore == devilution::TalkID::Storyteller) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::StorytellerIdentify); + } + break; + case StoreOption::EXIT: + switch (devilution::ActiveStore) { + case devilution::TalkID::Barmaid: + case devilution::TalkID::Boy: + case devilution::TalkID::BoyBuy: + case devilution::TalkID::Drunk: + case devilution::TalkID::Healer: + case devilution::TalkID::Smith: + case devilution::TalkID::Storyteller: + case devilution::TalkID::Tavern: + case devilution::TalkID::Witch: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::ActiveStore = devilution::TalkID::None; + } + break; + case StoreOption::BUYITEMS: + switch (devilution::ActiveStore) { + case devilution::TalkID::Witch: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::WitchBuy); + break; + case devilution::TalkID::Healer: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::HealerBuy); + break; + } + break; + case StoreOption::BUYBASIC: + if (devilution::ActiveStore == devilution::TalkID::Smith) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::SmithBuy); + } + break; + case StoreOption::BUYPREMIUM: + if (devilution::ActiveStore == devilution::TalkID::Smith) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::SmithPremiumBuy); + } + break; + case StoreOption::SELL: + switch (devilution::ActiveStore) { + case devilution::TalkID::Smith: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::SmithSell); + break; + case devilution::TalkID::Witch: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::WitchSell); + break; + } + break; + case StoreOption::REPAIR: + if (devilution::ActiveStore == devilution::TalkID::Smith) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::SmithRepair); + } + break; + case StoreOption::RECHARGE: + if (devilution::ActiveStore == devilution::TalkID::Witch) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::WitchRecharge); + } + break; + case StoreOption::WIRTPEEK: + if (devilution::ActiveStore == devilution::TalkID::Boy) { + if (50 <= devilution::Players[devilution::MyPlayerId]._pGold) { + devilution::TakePlrsMoney(50); + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::BoyBuy); + } else { + devilution::OldActiveStore = devilution::TalkID::Boy; + devilution::OldTextLine = 18; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::StartStore(devilution::TalkID::NoMoney); + } + } + break; + case StoreOption::BACK: + switch (devilution::ActiveStore) { + case devilution::TalkID::SmithRepair: + case devilution::TalkID::SmithSell: + case devilution::TalkID::SmithBuy: + case devilution::TalkID::SmithPremiumBuy: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::Smith); + break; + case devilution::TalkID::WitchBuy: + case devilution::TalkID::WitchSell: + case devilution::TalkID::WitchRecharge: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::Witch); + break; + case devilution::TalkID::HealerBuy: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::Healer); + break; + case devilution::TalkID::StorytellerIdentify: + devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::StartStore(devilution::TalkID::Storyteller); + break; + } + } +} + +void Server::buyItem(int itemID) +{ + int idx; + + if (devilution::ActiveStore == devilution::TalkID::WitchBuy) { + + idx = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::WitchItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::OldActiveStore = devilution::ActiveStore; + + + if (!devilution::PlayerCanAfford(devilution::WitchItems[idx]._iIvalue)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else if (devilution::StoreAutoPlace(devilution::WitchItems[idx], true)) { + if (idx < 3) + devilution::WitchItems[idx]._iSeed = devilution::AdvanceRndSeed(); + + devilution::TakePlrsMoney(devilution::Players[devilution::MyPlayerId].HoldItem._iIvalue); + + + if (idx >= 3) { + if (idx == devilution::NumWitchItemsHf - 1) + devilution::WitchItems[devilution::NumWitchItemsHf - 1].clear(); + else { + for (; !devilution::WitchItems[idx + 1].isEmpty(); idx++) { + devilution::WitchItems[idx] = std::move(devilution::WitchItems[idx + 1]); + } + devilution::WitchItems[idx].clear(); + } + } + + devilution::CalcPlrInv(*devilution::MyPlayer, true); + } else { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } + devilution::StartStore(devilution::OldActiveStore); + } else if (devilution::ActiveStore == devilution::TalkID::SmithBuy) { + idx = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::SmithItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::OldActiveStore = devilution::TalkID::SmithBuy; + + if (!devilution::PlayerCanAfford(devilution::SmithItems[idx]._iIvalue)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else if (!devilution::StoreAutoPlace(devilution::SmithItems[idx], false)) { + devilution::StartStore(devilution::TalkID::NoRoom); + } else { + devilution::TakePlrsMoney(devilution::SmithItems[idx]._iIvalue); + if (devilution::SmithItems[idx]._iMagical == devilution::item_quality::ITEM_QUALITY_NORMAL) + devilution::SmithItems[idx]._iIdentified = false; + devilution::StoreAutoPlace(devilution::SmithItems[idx], true); + if (idx == devilution::NumSmithBasicItemsHf - 1) { + devilution::SmithItems[devilution::NumSmithBasicItemsHf - 1].clear(); + } else { + for (; !devilution::SmithItems[idx + 1].isEmpty(); idx++) { + devilution::SmithItems[idx] = std::move(devilution::SmithItems[idx + 1]); + } + devilution::SmithItems[idx].clear(); + } + devilution::CalcPlrInv(*devilution::MyPlayer, true); + devilution::StartStore(devilution::OldActiveStore); + } + } else if (devilution::ActiveStore == devilution::TalkID::SmithPremiumBuy) { + int idx = -1; + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::PremiumItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::OldActiveStore = devilution::TalkID::SmithBuy; + + if (!devilution::PlayerCanAfford(devilution::PremiumItems[idx]._iIvalue)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else if (!devilution::StoreAutoPlace(devilution::PremiumItems[idx], false)) { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } else { + devilution::TakePlrsMoney(devilution::PremiumItems[idx]._iIvalue); + if (devilution::PremiumItems[idx]._iMagical == devilution::item_quality::ITEM_QUALITY_NORMAL) + devilution::PremiumItems[idx]._iIdentified = false; + devilution::StoreAutoPlace(devilution::PremiumItems[idx], true); + if (idx == devilution::NumSmithBasicItemsHf - 1) { + devilution::PremiumItems[devilution::NumSmithBasicItemsHf - 1].clear(); + } else { + for (; !devilution::PremiumItems[idx + 1].isEmpty(); idx++) { + devilution::PremiumItems[idx] = std::move(devilution::PremiumItems[idx + 1]); + } + devilution::PremiumItems[idx].clear(); + } + devilution::CalcPlrInv(*devilution::MyPlayer, true); + devilution::StartStore(devilution::OldActiveStore); + } + } else if (devilution::ActiveStore == devilution::TalkID::HealerBuy) { + idx = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::HealerItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::OldActiveStore = devilution::TalkID::HealerBuy; + + if (!devilution::PlayerCanAfford(devilution::HealerItems[idx]._iIvalue)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else if (!devilution::StoreAutoPlace(devilution::HealerItems[idx], false)) { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } else { + if (!devilution::gbIsMultiplayer) { + if (idx < 2) + devilution::HealerItems[idx]._iSeed = devilution::AdvanceRndSeed(); + } else { + if (idx < 3) + devilution::HealerItems[idx]._iSeed = devilution::AdvanceRndSeed(); + } + + devilution::TakePlrsMoney(devilution::HealerItems[idx]._iIvalue); + if (devilution::HealerItems[idx]._iMagical == devilution::item_quality::ITEM_QUALITY_NORMAL) + devilution::HealerItems[idx]._iIdentified = false; + devilution::StoreAutoPlace(devilution::HealerItems[idx], true); + + if (!devilution::gbIsMultiplayer) { + if (idx < 2) + return; + } else { + if (idx < 3) + return; + } + } + if (idx == 19) { + devilution::HealerItems[19].clear(); + } else { + for (; !devilution::HealerItems[idx + 1].isEmpty(); idx++) { + devilution::HealerItems[idx] = std::move(devilution::HealerItems[idx + 1]); + } + devilution::HealerItems[idx].clear(); + } + CalcPlrInv(*devilution::MyPlayer, true); + devilution::StartStore(devilution::OldActiveStore); + } else if (devilution::ActiveStore == devilution::TalkID::BoyBuy) { + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldActiveStore = devilution::TalkID::BoyBuy; + devilution::OldScrollPos = devilution::ScrollPos; + devilution::OldTextLine = 10; + + int price = devilution::BoyItem._iIvalue; + if (devilution::gbIsHellfire) + price -= devilution::BoyItem._iIvalue / 4; + else + price += devilution::BoyItem._iIvalue / 2; + + if (!devilution::PlayerCanAfford(price)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else if (!devilution::StoreAutoPlace(devilution::BoyItem, false)) { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } else { + devilution::TakePlrsMoney(price); + devilution::StoreAutoPlace(devilution::BoyItem, true); + devilution::BoyItem.clear(); + devilution::OldActiveStore = devilution::TalkID::Boy; + devilution::OldTextLine = 12; + } + devilution::StartStore(devilution::OldActiveStore); + } +} + +void Server::sellItem(int itemID) +{ + int idx; + + if (devilution::ActiveStore != devilution::TalkID::WitchSell &&devilution::ActiveStore != devilution::TalkID::SmithSell) + return; + + idx = -1; + + for (int i = 0; i < 48; i++) { + if (data->itemList[itemID].compare(devilution::PlayerItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldActiveStore = devilution::TalkID::SmithSell; + devilution::OldScrollPos = devilution::ScrollPos; + + if (!devilution::StoreGoldFit(devilution::PlayerItems[idx])) { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } + + devilution::Player &myPlayer = *devilution::MyPlayer; + + if (devilution::PlayerItemIndexes[idx] >= 0) + myPlayer.RemoveInvItem(devilution::PlayerItemIndexes[idx]); + else + myPlayer.RemoveSpdBarItem(-(devilution::PlayerItemIndexes[idx] + 1)); + + int cost = devilution::PlayerItems[idx]._iIvalue; + devilution::CurrentItemIndex--; + if (idx != devilution::CurrentItemIndex) { + while (idx < devilution::CurrentItemIndex) { + devilution::PlayerItems[idx] = devilution::PlayerItems[idx + 1]; + devilution::PlayerItemIndexes[idx] = devilution::PlayerItemIndexes[idx + 1]; + idx++; + } + } + + devilution::AddGoldToInventory(myPlayer, cost); + + myPlayer._pGold += cost; + devilution::StartStore(devilution::OldActiveStore); +} + +void Server::rechargeItem(int itemID) +{ + int idx; + + if (devilution::ActiveStore != devilution::TalkID::WitchRecharge) + return; + + idx = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::PlayerItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldActiveStore = devilution::TalkID::WitchRecharge; + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + + int price = devilution::PlayerItems[idx]._iIvalue; + + if (!devilution::PlayerCanAfford(price)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else { + devilution::PlayerItems[idx]._iCharges = devilution::PlayerItems[idx]._iMaxCharges; + + devilution::Player &myPlayer = *devilution::MyPlayer; + + int8_t i = devilution::PlayerItemIndexes[idx]; + if (i < 0) { + myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._iCharges = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._iMaxCharges; + devilution::NetSendCmdChItem(true, devilution::inv_body_loc::INVLOC_HAND_LEFT); + } else { + myPlayer.InvList[i]._iCharges = myPlayer.InvList[i]._iMaxCharges; + devilution::NetSyncInvItem(myPlayer, i); + } + + devilution::TakePlrsMoney(price); + devilution::CalcPlrInv(myPlayer, true); + devilution::StartStore(devilution::OldActiveStore); + } +} + +void Server::repairItem(int itemID) +{ + int idx; + + if (devilution::ActiveStore != devilution::TalkID::SmithRepair) + return; + + idx = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::PlayerItems[i])) { + idx = i; + break; + } + } + + if (idx == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldActiveStore = devilution::TalkID::SmithRepair; + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + + int price = devilution::PlayerItems[idx]._iIvalue; + + if (!devilution::PlayerCanAfford(price)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } + + devilution::PlayerItems[idx]._iDurability = devilution::PlayerItems[idx]._iMaxDur; + + int8_t i = devilution::PlayerItemIndexes[idx]; + + devilution::Player &myPlayer = *devilution::MyPlayer; + + if (i < 0) { + if (i == -1) + myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HEAD]._iDurability = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HEAD]._iMaxDur; + if (i == -2) + myPlayer.InvBody[devilution::inv_body_loc::INVLOC_CHEST]._iDurability = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_CHEST]._iMaxDur; + if (i == -3) + myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._iDurability = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._iMaxDur; + if (i == -4) + myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._iDurability = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._iMaxDur; + devilution::TakePlrsMoney(price); + devilution::StartStore(devilution::OldActiveStore); + } + + myPlayer.InvList[i]._iDurability = myPlayer.InvList[i]._iMaxDur; + devilution::TakePlrsMoney(price); + devilution::StartStore(devilution::OldActiveStore); +} + +void Server::attackMonster(int index) +{ + if (index < 0 || 199 < index) + return; + + if (!OKToAct()) + return; + + if (!isOnScreen(devilution::Monsters[index].position.tile.x, devilution::Monsters[index].position.tile.y)) + return; + + if (devilution::M_Talker(devilution::Monsters[index])) + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ATTACKID, index); + else if (devilution::Players[devilution::MyPlayerId].InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._itype == devilution::ItemType::Bow || devilution::Players[devilution::MyPlayerId].InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._itype == devilution::ItemType::Bow) + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_RATTACKID, index); + else + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ATTACKID, index); +} + +void Server::attackXY(int x, int y) +{ + if (!isOnScreen(x, y)) + return; + + if (!OKToAct()) + return; + + if (devilution::Players[devilution::MyPlayerId].InvBody[devilution::inv_body_loc::INVLOC_HAND_LEFT]._itype == devilution::ItemType::Bow || devilution::Players[devilution::MyPlayerId].InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._itype == devilution::ItemType::Bow) + devilution::NetSendCmdLoc(devilution::MyPlayerId, true, devilution::_cmd_id::CMD_RATTACKXY, devilution::Point { x, y }); + else + devilution::NetSendCmdLoc(devilution::MyPlayerId, true, devilution::_cmd_id::CMD_SATTACKXY, devilution::Point { x, y }); +} + +void Server::operateObject(int index) +{ + if (index < 0 || 126 < index) + return; + + if (!isOnScreen(devilution::Objects[index].position.x, devilution::Objects[index].position.y)) + return; + + if (!OKToAct()) + return; + + bool found = false; + for (int i = 0; i < devilution::ActiveObjectCount; i++) { + if (devilution::ActiveObjects[i] == index) { + found = true; + break; + } + } + + if (!found) + return; + + devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_OPOBJXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }, index); +} + +void Server::useBeltItem(int slot) +{ + if (slot < 0 || 7 < slot) + return; + + if (devilution::Players[devilution::MyPlayerId].SpdList[slot]._itype == devilution::ItemType::None) + return; + + int cii = slot + 47; + devilution::UseInvItem(cii); +} + +void Server::toggleCharacterScreen() +{ + if (!OKToAct()) + return; + + devilution::CharFlag = !devilution::CharFlag; +} + +void Server::increaseStat(CommandType commandType) +{ + int maxValue = 0; + + if (devilution::Players[devilution::MyPlayerId]._pStatPts == 0) + return; + + switch (commandType) { + case CommandType::ADDSTR: + switch (static_cast(devilution::Players[devilution::MyPlayerId]._pClass)) { + case devilution::HeroClass::Warrior: + maxValue = 250; + break; + case devilution::HeroClass::Rogue: + maxValue = 55; + break; + case devilution::HeroClass::Sorcerer: + maxValue = 45; + break; + } + if (devilution::Players[devilution::MyPlayerId]._pBaseStr < maxValue) { + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDSTR, 1); + devilution::Players[devilution::MyPlayerId]._pStatPts -= 1; + } + break; + case CommandType::ADDMAG: + switch (static_cast(devilution::Players[devilution::MyPlayerId]._pClass)) { + case devilution::HeroClass::Warrior: + maxValue = 50; + break; + case devilution::HeroClass::Rogue: + maxValue = 70; + break; + case devilution::HeroClass::Sorcerer: + maxValue = 250; + break; + } + if (devilution::Players[devilution::MyPlayerId]._pBaseMag < maxValue) { + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDMAG, 1); + devilution::Players[devilution::MyPlayerId]._pStatPts -= 1; + } + break; + case CommandType::ADDDEX: + switch (static_cast(devilution::Players[devilution::MyPlayerId]._pClass)) { + case devilution::HeroClass::Warrior: + maxValue = 60; + break; + case devilution::HeroClass::Rogue: + maxValue = 250; + break; + case devilution::HeroClass::Sorcerer: + maxValue = 85; + break; + } + if (devilution::Players[devilution::MyPlayerId]._pBaseDex < maxValue) { + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDDEX, 1); + devilution::Players[devilution::MyPlayerId]._pStatPts -= 1; + } + break; + case CommandType::ADDVIT: + switch (static_cast(devilution::Players[devilution::MyPlayerId]._pClass)) { + case devilution::HeroClass::Warrior: + maxValue = 100; + break; + case devilution::HeroClass::Rogue: + maxValue = 80; + break; + case devilution::HeroClass::Sorcerer: + maxValue = 80; + break; + } + if (devilution::Players[devilution::MyPlayerId]._pBaseVit < maxValue) { + devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDVIT, 1); + devilution::Players[devilution::MyPlayerId]._pStatPts -= 1; + } + } +} + +void Server::getItem(int itemID) +{ + if (!OKToAct()) + return; + + bool found = false; + + for (auto i = 0; i < data->groundItems.size(); i++) { + if (data->groundItems[i] == itemID) + found = true; + if (found) + break; + } + + if (!found) + return; + + auto itemData = data->itemList[itemID]; + + if (!isOnScreen(itemData._ix, itemData._iy)) + return; + + int index = -1; + for (int i = 0; i < devilution::ActiveItemCount; i++) { + if (itemData.compare(devilution::Items[devilution::ActiveItems[i]])) + index = devilution::ActiveItems[i]; + + if (index != -1) + break; + } + + if (index == -1) + return; + + if (devilution::invflag) + devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_GOTOGETITEM, devilution::Point { itemData._ix, itemData._iy }, index); + else + devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_GOTOAGETITEM, devilution::Point { itemData._ix, itemData._iy }, index); +} + +void Server::setSpell(int spellID, devilution::SpellType spellType) +{ + if (spellID == -1) + return; + + switch (spellType) { + case devilution::SpellType::Skill: + if (!(devilution::Players[devilution::MyPlayerId]._pAblSpells & (1 << (spellID - 1)))) + return; + break; + case devilution::SpellType::Spell: + if (!(devilution::Players[devilution::MyPlayerId]._pMemSpells & (1 << (spellID - 1)))) + return; + break; + case devilution::SpellType::Scroll: + if (!(devilution::Players[devilution::MyPlayerId]._pScrlSpells & (1 << (spellID - 1)))) + return; + break; + case devilution::SpellType::Charges: + if ((devilution::Players[devilution::MyPlayerId].InvBody[4]._iSpell != static_cast(spellID) && devilution::Players[devilution::MyPlayerId].InvBody[5]._iSpell != static_cast(spellID)) || (devilution::Players[devilution::MyPlayerId].InvBody[4]._iCharges == 0 && devilution::Players[devilution::MyPlayerId].InvBody[5]._iCharges == 0)) + return; + break; + case devilution::SpellType::Invalid: + default: + return; + break; + } + + devilution::Players[devilution::MyPlayerId]._pRSpell = static_cast(spellID); + devilution::Players[devilution::MyPlayerId]._pRSplType = static_cast(spellType); + //*force_redraw = 255; // TODO: Is this line needed in devilutionX? If so, what is it? +} + +void Server::castSpell(int index) +{ + if (!OKToAct()) + return; + + devilution::pcursmonst = index; + devilution::PlayerUnderCursor = nullptr; + devilution::cursPosition = devilution::Point { devilution::Monsters[index].position.tile.x, devilution::Monsters[index].position.tile.y }; + + devilution::CheckPlrSpell(false); +} + +void Server::toggleInventory() +{ + if (!OKToAct()) + return; + + devilution::invflag = !devilution::invflag; +} + +void Server::putInCursor(int itemID) +{ + if (!OKToAct()) + return; + + if (data->itemList.size() <= itemID) + return; + + auto item = data->itemList[itemID]; + int mx, my; + + mx = 0; + my = 0; + for (int i = 0; i < 55; i++) { + if (i < 7) { + if (item.compare(devilution::Players[devilution::MyPlayerId].InvBody[i]) && devilution::Players[devilution::MyPlayerId].InvBody[i]._itype != devilution::ItemType::None) { + if (!devilution::invflag) + return; + + switch (static_cast(i)) { + case EquipSlot::HEAD: + mx = devilution::InvRect[0].position.x + 1; + my = devilution::InvRect[0].position.y - 1; + break; + case EquipSlot::LEFTRING: + mx = devilution::InvRect[4].position.x + 1; + my = devilution::InvRect[4].position.y - 1; + break; + case EquipSlot::RIGHTRING: + mx = devilution::InvRect[5].position.x + 1; + my = devilution::InvRect[5].position.y - 1; + break; + case EquipSlot::AMULET: + mx = devilution::InvRect[6].position.x + 1; + my = devilution::InvRect[6].position.y - 1; + break; + case EquipSlot::LEFTHAND: + mx = devilution::InvRect[7].position.x + 1; + my = devilution::InvRect[7].position.y - 1; + break; + case EquipSlot::RIGHTHAND: + mx = devilution::InvRect[13].position.x + 1; + my = devilution::InvRect[13].position.y - 1; + break; + case EquipSlot::BODY: + mx = devilution::InvRect[19].position.x + 1; + my = devilution::InvRect[19].position.y - 1; + break; + } + break; + } + } else if (i < 47) { + if (item.compare(devilution::Players[devilution::MyPlayerId].InvList[i - 7]) && devilution::Players[devilution::MyPlayerId].InvList[i - 7]._itype != devilution::ItemType::None && i - 7 < devilution::Players[devilution::MyPlayerId]._pNumInv) { + if (!devilution::invflag) + return; + + for (int rect_index = 0; rect_index < 40; rect_index++) { + if (devilution::Players[devilution::MyPlayerId].InvGrid[rect_index] == i - 6) { + int index = rect_index + 25; + mx = devilution::InvRect[index].position.x + 1; + my = devilution::InvRect[index].position.y - 1; + break; + } + } + break; + } + } else { + if (item.compare(devilution::Players[devilution::MyPlayerId].SpdList[i - 47]) && devilution::Players[devilution::MyPlayerId].SpdList[i - 47]._itype != devilution::ItemType::None) { + int index = 18 + i; + mx = 210 + (i - 47) * 30; + my = 370; + break; + } + } + } + if (mx != 0 && my != 0) + devilution::CheckInvCut(*devilution::MyPlayer, devilution::Point { mx, my }, false, false); +} + +void Server::putCursorItem(int location) +{ + int mx, my; + EquipSlot equipLocation = static_cast(location); + + if (!data->invflag) + return; + + if (12 <= data->pcurs && equipLocation <= EquipSlot::BELT8) { + mx = 0; + my = 0; + switch (equipLocation) { + case EquipSlot::HEAD: + mx = devilution::InvRect[0].position.x + 1; + my = devilution::InvRect[0].position.y - 1; + break; + case EquipSlot::LEFTRING: + mx = devilution::InvRect[4].position.x + 2; + my = devilution::InvRect[4].position.y - 20; + break; + case EquipSlot::RIGHTRING: + mx = devilution::InvRect[5].position.x + 2; + my = devilution::InvRect[5].position.y - 20; + break; + case EquipSlot::AMULET: + mx = devilution::InvRect[6].position.x + 2; + my = devilution::InvRect[6].position.y - 20; + break; + case EquipSlot::LEFTHAND: + mx = devilution::InvRect[7].position.x + 1; + my = devilution::InvRect[7].position.y - 1; + break; + case EquipSlot::RIGHTHAND: + mx = devilution::InvRect[13].position.x + 1; + my = devilution::InvRect[13].position.y - 1; + break; + case EquipSlot::BODY: + mx = devilution::InvRect[19].position.x + 1; + my = devilution::InvRect[19].position.y - 1; + break; + default: + if (equipLocation < EquipSlot::BELT1) { + int index = 18 + location; + mx = devilution::InvRect[index].position.x + 2; + my = devilution::InvRect[index].position.y - 20; + } else { + int index = 18 + location; + mx = 210 + (location - 47) * 30; + my = 370; + } + break; + } + devilution::CheckInvPaste(*devilution::MyPlayer, devilution::Point { mx, my }); + } +} + +void Server::dropCursorItem() +{ + if (!isOnScreen(devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y)) + return; + + if (12 <= data->pcurs) { + devilution::NetSendCmdPItem(true, devilution::_cmd_id::CMD_PUTITEM, devilution::Point { devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y }, devilution::MyPlayer->HoldItem); + devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); + } +} + +void Server::useItem(int itemID) +{ + if (!OKToAct()) + return; + + if (data->itemList.size() <= itemID) + return; + + auto itemData = data->itemList[itemID]; + for (int i = 0; i < 8; i++) { + if (devilution::Players[devilution::MyPlayerId].SpdList[i]._itype != devilution::ItemType::None && itemData.compare(devilution::Players[devilution::MyPlayerId].SpdList[i])) { + useBeltItem(i); + return; + } + } + + for (int i = 0; i < devilution::Players[devilution::MyPlayerId]._pNumInv; i++) { + if (devilution::Players[devilution::MyPlayerId].InvList[i]._itype != devilution::ItemType::None && itemData.compare(devilution::Players[devilution::MyPlayerId].InvList[i])) { + devilution::UseInvItem(i + 7); + return; + } + } +} + +void Server::identifyStoreItem(int itemID) +{ + int id; + + if (devilution::ActiveStore != devilution::TalkID::StorytellerIdentify) + return; + + id = -1; + + for (int i = 0; i < 20; i++) { + if (data->itemList[itemID].compare(devilution::PlayerItems[i])) { + id = i; + break; + } + } + + if (id == -1) + return; + + devilution::PlaySFX(devilution::SfxID::MenuSelect); + + devilution::OldActiveStore = devilution::TalkID::StorytellerIdentify; + devilution::OldTextLine = devilution::CurrentTextLine; + devilution::OldScrollPos = devilution::ScrollPos; + + if (!devilution::PlayerCanAfford(devilution::PlayerItems[id]._iIvalue)) { + devilution::StartStore(devilution::TalkID::NoMoney); + return; + } else { + devilution::Player &myPlayer = *devilution::MyPlayer; + + int idx = devilution::PlayerItemIndexes[idx]; + if (idx < 0) { + if (idx == -1) + myPlayer.InvBody[devilution::INVLOC_HEAD]._iIdentified = true; + if (idx == -2) + myPlayer.InvBody[devilution::INVLOC_CHEST]._iIdentified = true; + if (idx == -3) + myPlayer.InvBody[devilution::INVLOC_HAND_LEFT]._iIdentified = true; + if (idx == -4) + myPlayer.InvBody[devilution::INVLOC_HAND_RIGHT]._iIdentified = true; + if (idx == -5) + myPlayer.InvBody[devilution::INVLOC_RING_LEFT]._iIdentified = true; + if (idx == -6) + myPlayer.InvBody[devilution::INVLOC_RING_RIGHT]._iIdentified = true; + if (idx == -7) + myPlayer.InvBody[devilution::INVLOC_AMULET]._iIdentified = true; + } else { + myPlayer.InvList[idx]._iIdentified = true; + } + devilution::PlayerItems[id]._iIdentified = true; + devilution::TakePlrsMoney(devilution::PlayerItems[id]._iIvalue); + devilution::CalcPlrInv(myPlayer, true); + } +} + +void Server::castSpell(int x, int y) +{ + if (!OKToAct()) + return; + + if (!isOnScreen(x, y)) + return; + + devilution::pcursmonst = -1; + devilution::PlayerUnderCursor = nullptr; + devilution::cursPosition = devilution::Point { x, y }; + + devilution::CheckPlrSpell(false); +} + +void Server::cancelQText() +{ + if (!data->qtextflag) + return; + + devilution::qtextflag = FALSE; + data->qtextflag = false; + devilution::stream_stop(); +} + +void Server::setFPS(int newFPS) +{ + FPS = newFPS; +} + +void Server::disarmTrap(int index) +{ + if (data->pcurs != devilution::cursor_id::CURSOR_DISARM) + return; + + if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Rogue) + return; + + devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_DISARMXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }, index); +} + +void Server::skillRepair(int itemID) +{ + if (data->pcurs != devilution::cursor_id::CURSOR_REPAIR) + return; + + if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Warrior) + return; + + if (!data->invflag) + return; + + for (int i = 0; i < 7; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvBody[i])) { + devilution::DoRepair(*devilution::MyPlayer, i); + return; + } + } + for (int i = 0; i < MAXINV; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvList[i])) { + devilution::DoRepair(*devilution::MyPlayer, i + 7); + return; + } + } +} + +void Server::skillRecharge(int itemID) +{ + if (static_cast(data->pcurs) != devilution::cursor_id::CURSOR_RECHARGE) + return; + + if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Sorcerer) + return; + + for (int i = 0; i < 7; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvBody[i])) { + devilution::DoRecharge(*devilution::MyPlayer, i); + return; + } + } + for (int i = 0; i < MAXINV; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvList[i])) { + devilution::DoRecharge(*devilution::MyPlayer, i + 7); + return; + } + } +} + +void Server::toggleMenu() +{ + devilution::qtextflag = false; + if (!devilution::gmenu_is_active()) + devilution::gamemenu_on(); + else + devilution::gamemenu_off(); + return; +} + +void Server::saveGame() +{ + if (devilution::gbIsMultiplayer || !devilution::gmenu_is_active()) + return; + + devilution::gmenu_presskeys(SDLK_KP_ENTER); + return; +} + +void Server::quit() +{ + if (!devilution::gmenu_is_active()) + return; + + devilution::gmenu_presskeys(SDLK_UP); + devilution::gmenu_presskeys(SDLK_KP_ENTER); + return; +} + +void Server::clearCursor() +{ + if (devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_REPAIR) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_DISARM) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_RECHARGE) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_IDENTIFY)) + devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); + + return; +} + +void Server::identifyItem(int itemID) +{ + if (static_cast(data->pcurs) != devilution::cursor_id::CURSOR_IDENTIFY) + return; + + if (!data->invflag) + return; + + for (int i = 0; i < 7; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvBody[i])) { + devilution::CheckIdentify(*devilution::MyPlayer, i); + return; + } + } + for (int i = 0; i < MAXINV; i++) { + if (data->itemList[itemID].compare(devilution::Players[devilution::MyPlayerId].InvList[i])) { + devilution::CheckIdentify(*devilution::MyPlayer, i + 7); + return; + } + } +} +} // namespace DAPI diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h new file mode 100644 index 000000000..947ca1003 --- /dev/null +++ b/Source/dapi/Server.h @@ -0,0 +1,254 @@ +#pragma once + +#include +#include +#include + +#include "Backend/DAPIBackendCore/DAPIProtoClient.h" +#include "GameData.h" + +#include "spelldat.h" +#include "player.h" +#include "control.h" +#include "inv.h" +#include "towners.h" +#include "stores.h" +#include "diablo.h" +#include "gmenu.h" +#include "cursor.h" +#include "minitext.h" +#include "levels/gendung.h" +#include "multi.h" +#include "objects.h" +#include "missiles.h" +#include "portal.h" +#include "msg.h" +#include "engine/random.hpp" +#include "gamemenu.h" + +namespace DAPI { +enum struct CommandType { + STAND, + WALKXY, + ACK_PLRINFO, + ADDSTR, + ADDMAG, + ADDDEX, + ADDVIT, + SBSPELL, + GETITEM, + AGETITEM, + PUTITEM, + RESPAWNITEM, + ATTACKXY, + RATTACKXY, + SPELLXY, + TSPELLXY, + OPOBJXY, + DISARMXY, + ATTACKID, + ATTACKPID, + RATTACKID, + RATTACKPID, + SPELLID, + SPELLPID, + TSPELLID, + TSPELLPID, + RESURRECT, + OPOBJT, + KNOCKBACK, + TALKXY, + NEWLVL, + WARP, + CHEAT_EXPERIENCE, + CHEAT_SPELL_LEVEL, + DEBUG, + SYNCDATA, + MONSTDEATH, + MONSTDAMAGE, + PLRDEAD, + REQUESTGITEM, + REQUESTAGITEM, + GOTOGETITEM, + GOTOAGETITEM, + OPENDOOR, + CLOSEDOOR, + OPERATEOBJ, + PLROPOBJ, + BREAKOBJ, + CHANGEPLRITEMS, + DELPLRITEMS, + PLRDAMAGE, + PLRLEVEL, + DROPITEM, + PLAYER_JOINLEVEL, + SEND_PLRINFO, + SATTACKXY, + ACTIVATEPORTAL, + DEACTIVATEPORTAL, + DLEVEL_0, + DLEVEL_1, + DLEVEL_2, + DLEVEL_3, + DLEVEL_4, + DLEVEL_5, + DLEVEL_6, + DLEVEL_7, + DLEVEL_8, + DLEVEL_9, + DLEVEL_10, + DLEVEL_11, + DLEVEL_12, + DLEVEL_13, + DLEVEL_14, + DLEVEL_15, + DLEVEL_16, + DLEVEL_JUNK, + DLEVEL_END, + HEALOTHER, + STRING, + SETSTR, + SETMAG, + SETDEX, + SETVIT, + RETOWN, + SPELLXYD, + ITEMEXTRA, + SYNCPUTITEM, + KILLGOLEM, + SYNCQUEST, + ENDSHIELD, + AWAKEGOLEM, + NOVA, + SETSHIELD, + REMSHIELD, + FAKE_SETID, + FAKE_DROPID, + TOGGLECHARACTER, + SETSPELL, + TOGGLEINVENTORY, + PUTINCURSOR, + PUTCURSORITEM, + IDENTIFYSTOREITEM, + NUM_CMDS, +}; + +enum struct EquipSlot { + HEAD = 0, + RIGHTRING = 1, + LEFTRING = 2, + AMULET = 3, + LEFTHAND = 4, + RIGHTHAND = 5, + BODY = 6, + INV1 = 7, + INV2 = 8, + INV3 = 9, + INV4 = 10, + INV5 = 11, + INV6 = 12, + INV7 = 13, + INV8 = 14, + INV9 = 15, + INV10 = 16, + INV11 = 17, + INV12 = 18, + INV13 = 19, + INV14 = 20, + INV15 = 21, + INV16 = 22, + INV17 = 23, + INV18 = 24, + INV19 = 25, + INV20 = 26, + INV21 = 27, + INV22 = 28, + INV23 = 29, + INV24 = 30, + INV25 = 31, + INV26 = 32, + INV27 = 33, + INV28 = 34, + INV29 = 35, + INV30 = 36, + INV31 = 37, + INV32 = 38, + INV33 = 39, + INV34 = 40, + INV35 = 41, + INV36 = 42, + INV37 = 43, + INV38 = 44, + INV39 = 45, + INV40 = 46, + BELT1 = 47, + BELT2 = 48, + BELT3 = 49, + BELT4 = 50, + BELT5 = 51, + BELT6 = 52, + BELT7 = 53, + BELT8 = 54 +}; + +struct Server { + Server(); + + Server(const Server &other) = delete; + Server(Server &&other) = delete; + + void update(); + bool isConnected() const; + + int FPS; + std::ofstream output; + +private: + void processMessages(); + void checkForConnections(); + void updateGameData(); + bool isOnScreen(int x, int y); + bool OKToAct(); + void move(int x, int y); + void talk(int x, int y); + void selectStoreOption(StoreOption option); + void buyItem(int itemID); + void sellItem(int itemID); + void rechargeItem(int itemID); + void repairItem(int itemID); + void attackMonster(int index); + void attackXY(int x, int y); + void operateObject(int index); + void useBeltItem(int slot); + void toggleCharacterScreen(); + void increaseStat(CommandType commandType); + void getItem(int itemID); + void setSpell(int spellID, devilution::SpellType spellType); + void castSpell(int index); + void toggleInventory(); + void putInCursor(int itemID); + void putCursorItem(int location); + void dropCursorItem(); + void useItem(int itemID); + void identifyStoreItem(int itemID); + void castSpell(int x, int y); + void cancelQText(); + void setFPS(int newFPS); + void disarmTrap(int index); + void skillRepair(int itemID); + void skillRecharge(int itemID); + void toggleMenu(); + void saveGame(); + void quit(); + void clearCursor(); + void identifyItem(int itemID); + + bool listening = false; + + std::unique_ptr data; + + std::map, bool> panelScreenCheck; + + DAPIProtoClient protoClient; +}; +} // namespace DAPI diff --git a/Source/dapi/Towner.h b/Source/dapi/Towner.h new file mode 100644 index 000000000..2a2266d0f --- /dev/null +++ b/Source/dapi/Towner.h @@ -0,0 +1,14 @@ +#pragma once + +#include "../towners.h" + +namespace DAPI { + +struct TownerData { + int ID; + devilution::_talker_id _ttype; + int _tx; + int _ty; + char _tName[32]; +}; +} // namespace DAPI diff --git a/Source/dapi/Trigger.h b/Source/dapi/Trigger.h new file mode 100644 index 000000000..63f6c7802 --- /dev/null +++ b/Source/dapi/Trigger.h @@ -0,0 +1,14 @@ +#pragma once +#include "../levels/trigs.h" + +namespace DAPI { +struct TriggerData { + bool compare(devilution::TriggerStruct &other) { return (other._tlvl == lvl && other._tmsg == type && other.position.x == x && other.position.y == y); } + + int ID; + int x; + int y; + int lvl; + int type; +}; +} // namespace DAPI diff --git a/Source/diablo.cpp b/Source/diablo.cpp index 7299b0dc5..e46c9ff22 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -26,6 +26,7 @@ #include "controls/keymapper.hpp" #include "controls/plrctrls.h" #include "controls/remap_keyboard.h" +#include "dapi/Server.h" #include "diablo.h" #include "diablo_msg.hpp" #include "discord/discord.h" @@ -132,6 +133,8 @@ clicktype sgbMouseDown; uint16_t gnTickDelay = 50; char gszProductName[64] = "DevilutionX vUnknown"; +DAPI::Server dapiServer; + #ifdef _DEBUG bool DebugDisableNetworkTimeout = false; std::vector DebugCmdsFromCommandLine; @@ -1458,6 +1461,7 @@ void GameLogic() if (!ProcessInput()) { return; } + dapiServer.update(); if (gbProcessPlayers) { gGameLogicStep = GameLogicStep::ProcessPlayers; ProcessPlayers(); diff --git a/Source/diablo.h b/Source/diablo.h index de321dccb..8be060669 100644 --- a/Source/diablo.h +++ b/Source/diablo.h @@ -79,6 +79,7 @@ extern clicktype sgbMouseDown; extern uint16_t gnTickDelay; extern char gszProductName[64]; + extern MouseActionType LastMouseButtonAction; void InitKeymapActions(); diff --git a/Source/inv.cpp b/Source/inv.cpp index 5b9a461c5..e3cdbf394 100644 --- a/Source/inv.cpp +++ b/Source/inv.cpp @@ -547,68 +547,6 @@ item_equip_type GetItemEquipType(const Player &player, int slot, item_equip_type return ILOC_UNEQUIPABLE; } -void CheckInvPaste(Player &player, Point cursorPosition) -{ - const Size itemSize = GetInventorySize(player.HoldItem); - - const int slot = FindTargetSlotUnderItemCursor(cursorPosition, itemSize); - if (slot == NUM_XY_SLOTS) - return; - - const item_equip_type desiredLocation = player.GetItemLocation(player.HoldItem); - const item_equip_type location = GetItemEquipType(player, slot, desiredLocation); - - if (location == ILOC_BELT) { - if (!CanBePlacedOnBelt(player, player.HoldItem)) return; - } else if (location != ILOC_UNEQUIPABLE) { - if (desiredLocation != location) return; - } - - if (IsNoneOf(location, ILOC_UNEQUIPABLE, ILOC_BELT)) { - if (!player.CanUseItem(player.HoldItem)) { - player.Say(HeroSpeech::ICantUseThisYet); - return; - } - if (player._pmode > PM_WALK_SIDEWAYS) - return; - } - - if (&player == MyPlayer) { - PlaySFX(ItemInvSnds[ItemCAnimTbl[player.HoldItem._iCurs]]); - } - - // Select the parameters that go into - // ChangeEquipment and add it to post switch - switch (location) { - case ILOC_HELM: - case ILOC_RING: - case ILOC_AMULET: - case ILOC_ARMOR: - ChangeBodyEquipment(player, slot, location); - break; - case ILOC_ONEHAND: - ChangeEquippedItem(player, slot); - break; - case ILOC_TWOHAND: - ChangeTwoHandItem(player); - break; - case ILOC_UNEQUIPABLE: - if (!ChangeInvItem(player, slot, itemSize)) return; - break; - case ILOC_BELT: - ChangeBeltItem(player, slot); - break; - case ILOC_NONE: - case ILOC_INVALID: - break; - } - - CalcPlrInv(player, true); - if (&player == MyPlayer) { - NewCursor(player.HoldItem); - } -} - inv_body_loc MapSlotToInvBodyLoc(inv_xy_slot slot) { assert(slot <= SLOTXY_CHEST); @@ -735,269 +673,60 @@ bool CouldFitItemInInventory(const Player &player, const Item &item, int itemInd return static_cast(FindSlotForItem(player, GetInventorySize(item), itemIndexToIgnore)); } -void CheckInvCut(Player &player, Point cursorPosition, bool automaticMove, bool dropItem) +void TryCombineNaKrulNotes(Player &player, Item ¬eItem) { - if (player._pmode > PM_WALK_SIDEWAYS) { + int idx = noteItem.IDidx; + _item_indexes notes[] = { IDI_NOTE1, IDI_NOTE2, IDI_NOTE3 }; + + if (IsNoneOf(idx, IDI_NOTE1, IDI_NOTE2, IDI_NOTE3)) { return; } - CloseGoldDrop(); + for (_item_indexes note : notes) { + if (idx != note && !HasInventoryItemWithId(player, note)) { + return; // the player doesn't have all notes + } + } - std::optional maybeSlot = FindSlotUnderCursor(cursorPosition); + MyPlayer->Say(HeroSpeech::JustWhatIWasLookingFor, 10); - if (!maybeSlot) { - // not on an inventory slot rectangle - return; + for (_item_indexes note : notes) { + if (idx != note) { + RemoveInventoryItemById(player, note); + } } - inv_xy_slot r = *maybeSlot; - - Item &holdItem = player.HoldItem; - holdItem.clear(); + Point position = noteItem.position; // copy the position to restore it after re-initialising the item + noteItem = {}; + GetItemAttrs(noteItem, IDI_FULLNOTE, 16); + SetupItem(noteItem); + noteItem.position = position; // this ensures CleanupItem removes the entry in the dropped items lookup table +} - bool attemptedMove = false; - bool automaticallyMoved = false; - SfxID successSound = SfxID::None; - HeroSpeech failedSpeech = HeroSpeech::ICantDoThat; // Default message if the player attempts to automove an item that can't go anywhere else +void CheckQuestItem(Player &player, Item &questItem) +{ + Player &myPlayer = *MyPlayer; - if (r >= SLOTXY_HEAD && r <= SLOTXY_CHEST) { - inv_body_loc invloc = MapSlotToInvBodyLoc(r); - if (!player.InvBody[invloc].isEmpty()) { - if (automaticMove) { - attemptedMove = true; - automaticallyMoved = AutoPlaceItemInInventory(player, player.InvBody[invloc]); - if (automaticallyMoved) { - successSound = ItemInvSnds[ItemCAnimTbl[player.InvBody[invloc]._iCurs]]; - RemoveEquipment(player, invloc, false); - } else { - failedSpeech = HeroSpeech::IHaveNoRoom; - } - } else { - holdItem = player.InvBody[invloc]; - RemoveEquipment(player, invloc, false); - } - } + if (Quests[Q_BLIND]._qactive == QUEST_ACTIVE + && (questItem.IDidx == IDI_OPTAMULET + || (Quests[Q_BLIND].IsAvailable() && questItem.position == (SetPiece.position.megaToWorld() + Displacement { 5, 5 })))) { + Quests[Q_BLIND]._qactive = QUEST_DONE; + NetSendCmdQuest(true, Quests[Q_BLIND]); } - if (r >= SLOTXY_INV_FIRST && r <= SLOTXY_INV_LAST) { - unsigned ig = r - SLOTXY_INV_FIRST; - int iv = std::abs(player.InvGrid[ig]) - 1; - if (iv >= 0) { - if (automaticMove) { - attemptedMove = true; - if (CanBePlacedOnBelt(player, player.InvList[iv])) { - automaticallyMoved = AutoPlaceItemInBelt(player, player.InvList[iv], true, &player == MyPlayer); - if (automaticallyMoved) { - successSound = SfxID::GrabItem; - player.RemoveInvItem(iv, false); - } else { - failedSpeech = HeroSpeech::IHaveNoRoom; - } - } else if (CanEquip(player.InvList[iv])) { - failedSpeech = HeroSpeech::IHaveNoRoom; // Default to saying "I have no room" if auto-equip fails - - /* - * If the player shift-clicks an item in the inventory we want to swap it with whatever item may be - * equipped in the target slot. Lifting the item to the hand unconditionally would be ideal, except - * we don't want to leave the item on the hand if the equip attempt failed. We would end up - * generating wasteful network messages if we did the lift first. Instead we work out whatever slot - * needs to be unequipped (if any): - */ - int invloc = NUM_INVLOC; - switch (player.GetItemLocation(player.InvList[iv])) { - case ILOC_ARMOR: - invloc = INVLOC_CHEST; - break; - case ILOC_HELM: - invloc = INVLOC_HEAD; - break; - case ILOC_AMULET: - invloc = INVLOC_AMULET; - break; - case ILOC_ONEHAND: - if (!player.InvBody[INVLOC_HAND_LEFT].isEmpty() - && (player.InvList[iv]._iClass == player.InvBody[INVLOC_HAND_LEFT]._iClass - || player.GetItemLocation(player.InvBody[INVLOC_HAND_LEFT]) == ILOC_TWOHAND)) { - // The left hand is not empty and we're either trying to equip the same type of item or - // it's holding a two handed weapon, so it must be unequipped - invloc = INVLOC_HAND_LEFT; - } else if (!player.InvBody[INVLOC_HAND_RIGHT].isEmpty() && player.InvList[iv]._iClass == player.InvBody[INVLOC_HAND_RIGHT]._iClass) { - // The right hand is not empty and we're trying to equip the same type of item, so we need - // to unequip that item - invloc = INVLOC_HAND_RIGHT; - } - // otherwise one hand is empty (and we can let the auto-equip code put the target item into - // that hand) or we're playing a bard with two swords equipped and we're trying to auto-equip - // a shield (in which case the attempt will fail). - break; - case ILOC_TWOHAND: - // Moving a two-hand item from inventory to InvBody requires emptying both hands. - if (player.InvBody[INVLOC_HAND_RIGHT].isEmpty()) { - // If the right hand is empty then we can simply try equipping this item in the left hand, - // we'll let the common code take care of unequipping anything held there. - invloc = INVLOC_HAND_LEFT; - } else if (player.InvBody[INVLOC_HAND_LEFT].isEmpty()) { - // We have an item in the right hand but nothing in the left, so let the common code - // take care of unequipping whatever is held in the right hand. The auto-equip code - // picks the most appropriate location for the item type (which in this case will be - // the left hand), invloc isn't used there. - invloc = INVLOC_HAND_RIGHT; - } else { - // Both hands are holding items, we must unequip one of the items and check that there's - // space for the other before trying to auto-equip - inv_body_loc mainHand = INVLOC_HAND_LEFT; - inv_body_loc offHand = INVLOC_HAND_RIGHT; - if (!AutoPlaceItemInInventory(player, player.InvBody[offHand])) { - // No space to move right hand item to inventory, can we move the left instead? - std::swap(mainHand, offHand); - if (!AutoPlaceItemInInventory(player, player.InvBody[offHand])) { - break; - } - } - if (!CouldFitItemInInventory(player, player.InvBody[mainHand], iv)) { - // No space for the main hand item. Move the other item back to the off hand and abort. - player.InvBody[offHand] = player.InvList[player._pNumInv - 1]; - player.RemoveInvItem(player._pNumInv - 1, false); - break; - } - RemoveEquipment(player, offHand, false); - invloc = mainHand; - } - break; - default: - // If the player is trying to equip a ring we want to say "I can't do that" if they don't already have a ring slot free. - failedSpeech = HeroSpeech::ICantDoThat; - break; - } - // Then empty the identified InvBody slot (invloc) and hand over to AutoEquip - if (invloc != NUM_INVLOC - && !player.InvBody[invloc].isEmpty() - && CouldFitItemInInventory(player, player.InvBody[invloc], iv)) { - holdItem = player.InvBody[invloc].pop(); - } - automaticallyMoved = AutoEquip(player, player.InvList[iv], true, &player == MyPlayer); - if (automaticallyMoved) { - successSound = ItemInvSnds[ItemCAnimTbl[player.InvList[iv]._iCurs]]; - player.RemoveInvItem(iv, false); + if (questItem.IDidx == IDI_MUSHROOM && Quests[Q_MUSHROOM]._qactive == QUEST_ACTIVE && Quests[Q_MUSHROOM]._qvar1 == QS_MUSHSPAWNED) { + player.Say(HeroSpeech::NowThatsOneBigMushroom, 10); // BUGFIX: Voice for this quest might be wrong in MP + Quests[Q_MUSHROOM]._qvar1 = QS_MUSHPICKED; + NetSendCmdQuest(true, Quests[Q_MUSHROOM]); + } - // If we're holding an item at this point we just lifted it from a body slot to make room for the original item, so we need to put it into the inv - if (!holdItem.isEmpty() && AutoPlaceItemInInventory(player, holdItem)) { - holdItem.clear(); - } // there should never be a situation where holdItem is not empty but we fail to place it into the inventory given the checks earlier... leave it on the hand in this case. - } else if (!holdItem.isEmpty()) { - // We somehow failed to equip the item in the slot we already checked should hold it? Better put this item back... - player.InvBody[invloc] = holdItem.pop(); - } - } - } else { - holdItem = player.InvList[iv]; - player.RemoveInvItem(iv, false); - } - } - } - - if (r >= SLOTXY_BELT_FIRST) { - Item &beltItem = player.SpdList[r - SLOTXY_BELT_FIRST]; - if (!beltItem.isEmpty()) { - if (automaticMove) { - attemptedMove = true; - automaticallyMoved = AutoPlaceItemInInventory(player, beltItem); - if (automaticallyMoved) { - successSound = SfxID::GrabItem; - player.RemoveSpdBarItem(r - SLOTXY_BELT_FIRST); - } else { - failedSpeech = HeroSpeech::IHaveNoRoom; - } - } else { - holdItem = beltItem; - player.RemoveSpdBarItem(r - SLOTXY_BELT_FIRST); - } - } - } - - if (!holdItem.isEmpty()) { - if (holdItem._itype == ItemType::Gold) { - player._pGold = CalculateGold(player); - } - - CalcPlrInv(player, true); - holdItem._iStatFlag = player.CanUseItem(holdItem); - - if (&player == MyPlayer) { - PlaySFX(SfxID::GrabItem); - NewCursor(holdItem); - } - if (dropItem) { - TryDropItem(); - } - } else if (automaticMove) { - if (automaticallyMoved) { - CalcPlrInv(player, true); - } - if (attemptedMove && &player == MyPlayer) { - if (automaticallyMoved) { - PlaySFX(successSound); - } else { - player.SaySpecific(failedSpeech); - } - } - } -} - -void TryCombineNaKrulNotes(Player &player, Item ¬eItem) -{ - int idx = noteItem.IDidx; - _item_indexes notes[] = { IDI_NOTE1, IDI_NOTE2, IDI_NOTE3 }; - - if (IsNoneOf(idx, IDI_NOTE1, IDI_NOTE2, IDI_NOTE3)) { - return; - } - - for (_item_indexes note : notes) { - if (idx != note && !HasInventoryItemWithId(player, note)) { - return; // the player doesn't have all notes - } - } - - MyPlayer->Say(HeroSpeech::JustWhatIWasLookingFor, 10); - - for (_item_indexes note : notes) { - if (idx != note) { - RemoveInventoryItemById(player, note); - } - } - - Point position = noteItem.position; // copy the position to restore it after re-initialising the item - noteItem = {}; - GetItemAttrs(noteItem, IDI_FULLNOTE, 16); - SetupItem(noteItem); - noteItem.position = position; // this ensures CleanupItem removes the entry in the dropped items lookup table -} - -void CheckQuestItem(Player &player, Item &questItem) -{ - Player &myPlayer = *MyPlayer; - - if (Quests[Q_BLIND]._qactive == QUEST_ACTIVE - && (questItem.IDidx == IDI_OPTAMULET - || (Quests[Q_BLIND].IsAvailable() && questItem.position == (SetPiece.position.megaToWorld() + Displacement { 5, 5 })))) { - Quests[Q_BLIND]._qactive = QUEST_DONE; - NetSendCmdQuest(true, Quests[Q_BLIND]); - } - - if (questItem.IDidx == IDI_MUSHROOM && Quests[Q_MUSHROOM]._qactive == QUEST_ACTIVE && Quests[Q_MUSHROOM]._qvar1 == QS_MUSHSPAWNED) { - player.Say(HeroSpeech::NowThatsOneBigMushroom, 10); // BUGFIX: Voice for this quest might be wrong in MP - Quests[Q_MUSHROOM]._qvar1 = QS_MUSHPICKED; - NetSendCmdQuest(true, Quests[Q_MUSHROOM]); - } - - if (questItem.IDidx == IDI_ANVIL && Quests[Q_ANVIL]._qactive != QUEST_NOTAVAIL) { - if (Quests[Q_ANVIL]._qactive == QUEST_INIT) { - Quests[Q_ANVIL]._qactive = QUEST_ACTIVE; - NetSendCmdQuest(true, Quests[Q_ANVIL]); - } - if (Quests[Q_ANVIL]._qlog) { - myPlayer.Say(HeroSpeech::INeedToGetThisToGriswold, 10); + if (questItem.IDidx == IDI_ANVIL && Quests[Q_ANVIL]._qactive != QUEST_NOTAVAIL) { + if (Quests[Q_ANVIL]._qactive == QUEST_INIT) { + Quests[Q_ANVIL]._qactive = QUEST_ACTIVE; + NetSendCmdQuest(true, Quests[Q_ANVIL]); + } + if (Quests[Q_ANVIL]._qlog) { + myPlayer.Say(HeroSpeech::INeedToGetThisToGriswold, 10); } } @@ -2274,4 +2003,275 @@ Size GetInventorySize(const Item &item) return { size.width / InventorySlotSizeInPixels.width, size.height / InventorySlotSizeInPixels.height }; } +void CheckInvCut(Player &player, Point cursorPosition, bool automaticMove, bool dropItem) +{ + if (player._pmode > PM_WALK_SIDEWAYS) { + return; + } + + CloseGoldDrop(); + + std::optional maybeSlot = FindSlotUnderCursor(cursorPosition); + + if (!maybeSlot) { + // not on an inventory slot rectangle + return; + } + + inv_xy_slot r = *maybeSlot; + + Item &holdItem = player.HoldItem; + holdItem.clear(); + + bool attemptedMove = false; + bool automaticallyMoved = false; + SfxID successSound = SfxID::None; + HeroSpeech failedSpeech = HeroSpeech::ICantDoThat; // Default message if the player attempts to automove an item that can't go anywhere else + + if (r >= SLOTXY_HEAD && r <= SLOTXY_CHEST) { + inv_body_loc invloc = MapSlotToInvBodyLoc(r); + if (!player.InvBody[invloc].isEmpty()) { + if (automaticMove) { + attemptedMove = true; + automaticallyMoved = AutoPlaceItemInInventory(player, player.InvBody[invloc]); + if (automaticallyMoved) { + successSound = ItemInvSnds[ItemCAnimTbl[player.InvBody[invloc]._iCurs]]; + RemoveEquipment(player, invloc, false); + } else { + failedSpeech = HeroSpeech::IHaveNoRoom; + } + } else { + holdItem = player.InvBody[invloc]; + RemoveEquipment(player, invloc, false); + } + } + } + + if (r >= SLOTXY_INV_FIRST && r <= SLOTXY_INV_LAST) { + unsigned ig = r - SLOTXY_INV_FIRST; + int iv = std::abs(player.InvGrid[ig]) - 1; + if (iv >= 0) { + if (automaticMove) { + attemptedMove = true; + if (CanBePlacedOnBelt(player, player.InvList[iv])) { + automaticallyMoved = AutoPlaceItemInBelt(player, player.InvList[iv], true, &player == MyPlayer); + if (automaticallyMoved) { + successSound = SfxID::GrabItem; + player.RemoveInvItem(iv, false); + } else { + failedSpeech = HeroSpeech::IHaveNoRoom; + } + } else if (CanEquip(player.InvList[iv])) { + failedSpeech = HeroSpeech::IHaveNoRoom; // Default to saying "I have no room" if auto-equip fails + + /* + * If the player shift-clicks an item in the inventory we want to swap it with whatever item may be + * equipped in the target slot. Lifting the item to the hand unconditionally would be ideal, except + * we don't want to leave the item on the hand if the equip attempt failed. We would end up + * generating wasteful network messages if we did the lift first. Instead we work out whatever slot + * needs to be unequipped (if any): + */ + int invloc = NUM_INVLOC; + switch (player.GetItemLocation(player.InvList[iv])) { + case ILOC_ARMOR: + invloc = INVLOC_CHEST; + break; + case ILOC_HELM: + invloc = INVLOC_HEAD; + break; + case ILOC_AMULET: + invloc = INVLOC_AMULET; + break; + case ILOC_ONEHAND: + if (!player.InvBody[INVLOC_HAND_LEFT].isEmpty() + && (player.InvList[iv]._iClass == player.InvBody[INVLOC_HAND_LEFT]._iClass + || player.GetItemLocation(player.InvBody[INVLOC_HAND_LEFT]) == ILOC_TWOHAND)) { + // The left hand is not empty and we're either trying to equip the same type of item or + // it's holding a two handed weapon, so it must be unequipped + invloc = INVLOC_HAND_LEFT; + } else if (!player.InvBody[INVLOC_HAND_RIGHT].isEmpty() && player.InvList[iv]._iClass == player.InvBody[INVLOC_HAND_RIGHT]._iClass) { + // The right hand is not empty and we're trying to equip the same type of item, so we need + // to unequip that item + invloc = INVLOC_HAND_RIGHT; + } + // otherwise one hand is empty (and we can let the auto-equip code put the target item into + // that hand) or we're playing a bard with two swords equipped and we're trying to auto-equip + // a shield (in which case the attempt will fail). + break; + case ILOC_TWOHAND: + // Moving a two-hand item from inventory to InvBody requires emptying both hands. + if (player.InvBody[INVLOC_HAND_RIGHT].isEmpty()) { + // If the right hand is empty then we can simply try equipping this item in the left hand, + // we'll let the common code take care of unequipping anything held there. + invloc = INVLOC_HAND_LEFT; + } else if (player.InvBody[INVLOC_HAND_LEFT].isEmpty()) { + // We have an item in the right hand but nothing in the left, so let the common code + // take care of unequipping whatever is held in the right hand. The auto-equip code + // picks the most appropriate location for the item type (which in this case will be + // the left hand), invloc isn't used there. + invloc = INVLOC_HAND_RIGHT; + } else { + // Both hands are holding items, we must unequip one of the items and check that there's + // space for the other before trying to auto-equip + inv_body_loc mainHand = INVLOC_HAND_LEFT; + inv_body_loc offHand = INVLOC_HAND_RIGHT; + if (!AutoPlaceItemInInventory(player, player.InvBody[offHand])) { + // No space to move right hand item to inventory, can we move the left instead? + std::swap(mainHand, offHand); + if (!AutoPlaceItemInInventory(player, player.InvBody[offHand])) { + break; + } + } + if (!CouldFitItemInInventory(player, player.InvBody[mainHand], iv)) { + // No space for the main hand item. Move the other item back to the off hand and abort. + player.InvBody[offHand] = player.InvList[player._pNumInv - 1]; + player.RemoveInvItem(player._pNumInv - 1, false); + break; + } + RemoveEquipment(player, offHand, false); + invloc = mainHand; + } + break; + default: + // If the player is trying to equip a ring we want to say "I can't do that" if they don't already have a ring slot free. + failedSpeech = HeroSpeech::ICantDoThat; + break; + } + // Then empty the identified InvBody slot (invloc) and hand over to AutoEquip + if (invloc != NUM_INVLOC + && !player.InvBody[invloc].isEmpty() + && CouldFitItemInInventory(player, player.InvBody[invloc], iv)) { + holdItem = player.InvBody[invloc].pop(); + } + automaticallyMoved = AutoEquip(player, player.InvList[iv], true, &player == MyPlayer); + if (automaticallyMoved) { + successSound = ItemInvSnds[ItemCAnimTbl[player.InvList[iv]._iCurs]]; + player.RemoveInvItem(iv, false); + + // If we're holding an item at this point we just lifted it from a body slot to make room for the original item, so we need to put it into the inv + if (!holdItem.isEmpty() && AutoPlaceItemInInventory(player, holdItem)) { + holdItem.clear(); + } // there should never be a situation where holdItem is not empty but we fail to place it into the inventory given the checks earlier... leave it on the hand in this case. + } else if (!holdItem.isEmpty()) { + // We somehow failed to equip the item in the slot we already checked should hold it? Better put this item back... + player.InvBody[invloc] = holdItem.pop(); + } + } + } else { + holdItem = player.InvList[iv]; + player.RemoveInvItem(iv, false); + } + } + } + + if (r >= SLOTXY_BELT_FIRST) { + Item &beltItem = player.SpdList[r - SLOTXY_BELT_FIRST]; + if (!beltItem.isEmpty()) { + if (automaticMove) { + attemptedMove = true; + automaticallyMoved = AutoPlaceItemInInventory(player, beltItem); + if (automaticallyMoved) { + successSound = SfxID::GrabItem; + player.RemoveSpdBarItem(r - SLOTXY_BELT_FIRST); + } else { + failedSpeech = HeroSpeech::IHaveNoRoom; + } + } else { + holdItem = beltItem; + player.RemoveSpdBarItem(r - SLOTXY_BELT_FIRST); + } + } + } + + if (!holdItem.isEmpty()) { + if (holdItem._itype == ItemType::Gold) { + player._pGold = CalculateGold(player); + } + + CalcPlrInv(player, true); + holdItem._iStatFlag = player.CanUseItem(holdItem); + + if (&player == MyPlayer) { + PlaySFX(SfxID::GrabItem); + NewCursor(holdItem); + } + if (dropItem) { + TryDropItem(); + } + } else if (automaticMove) { + if (automaticallyMoved) { + CalcPlrInv(player, true); + } + if (attemptedMove && &player == MyPlayer) { + if (automaticallyMoved) { + PlaySFX(successSound); + } else { + player.SaySpecific(failedSpeech); + } + } + } +} + +void CheckInvPaste(Player &player, Point cursorPosition) +{ + const Size itemSize = GetInventorySize(player.HoldItem); + + const int slot = FindTargetSlotUnderItemCursor(cursorPosition, itemSize); + if (slot == NUM_XY_SLOTS) + return; + + const item_equip_type desiredLocation = player.GetItemLocation(player.HoldItem); + const item_equip_type location = GetItemEquipType(player, slot, desiredLocation); + + if (location == ILOC_BELT) { + if (!CanBePlacedOnBelt(player, player.HoldItem)) return; + } else if (location != ILOC_UNEQUIPABLE) { + if (desiredLocation != location) return; + } + + if (IsNoneOf(location, ILOC_UNEQUIPABLE, ILOC_BELT)) { + if (!player.CanUseItem(player.HoldItem)) { + player.Say(HeroSpeech::ICantUseThisYet); + return; + } + if (player._pmode > PM_WALK_SIDEWAYS) + return; + } + + if (&player == MyPlayer) { + PlaySFX(ItemInvSnds[ItemCAnimTbl[player.HoldItem._iCurs]]); + } + + // Select the parameters that go into + // ChangeEquipment and add it to post switch + switch (location) { + case ILOC_HELM: + case ILOC_RING: + case ILOC_AMULET: + case ILOC_ARMOR: + ChangeBodyEquipment(player, slot, location); + break; + case ILOC_ONEHAND: + ChangeEquippedItem(player, slot); + break; + case ILOC_TWOHAND: + ChangeTwoHandItem(player); + break; + case ILOC_UNEQUIPABLE: + if (!ChangeInvItem(player, slot, itemSize)) return; + break; + case ILOC_BELT: + ChangeBeltItem(player, slot); + break; + case ILOC_NONE: + case ILOC_INVALID: + break; + } + + CalcPlrInv(player, true); + if (&player == MyPlayer) { + NewCursor(player.HoldItem); + } +} + } // namespace devilution diff --git a/Source/inv.h b/Source/inv.h index 4a1d56c70..f5ba70726 100644 --- a/Source/inv.h +++ b/Source/inv.h @@ -389,6 +389,10 @@ inline bool RemoveInventoryOrBeltItemById(Player &player, _item_indexes id) */ void ConsumeScroll(Player &player); +void CheckInvCut(Player &player, Point cursorPosition, bool automaticMove, bool dropItem); + +void CheckInvPaste(Player &player, Point cursorPosition); + /* data */ } // namespace devilution diff --git a/Source/minitext.cpp b/Source/minitext.cpp index c209a1cc3..8c38b51ab 100644 --- a/Source/minitext.cpp +++ b/Source/minitext.cpp @@ -26,6 +26,8 @@ namespace devilution { bool qtextflag; +std::vector TextLines; + namespace { /** Vertical speed of the scrolling text in ms/px */ @@ -38,8 +40,6 @@ OptionalOwnedClxSpriteList pTextBoxCels; /** Pixels for a line of text and the empty space under it. */ const int LineHeight = 38; -std::vector TextLines; - void LoadText(std::string_view text) { TextLines.clear(); diff --git a/Source/minitext.h b/Source/minitext.h index 9bfdcb6e2..32f7899ae 100644 --- a/Source/minitext.h +++ b/Source/minitext.h @@ -13,6 +13,8 @@ namespace devilution { /** Specify if the quest dialog window is being shown */ extern bool qtextflag; +extern std::vector TextLines; + /** * @brief Free the resources used by the quest dialog window */ diff --git a/Source/portal.cpp b/Source/portal.cpp index c206bcf41..2990f2548 100644 --- a/Source/portal.cpp +++ b/Source/portal.cpp @@ -16,11 +16,6 @@ namespace devilution { /** In-game state of portals. */ Portal Portals[MAXPORTAL]; -namespace { - -/** Current portal number (a portal array index). */ -size_t portalindex; - /** Coordinate of each player's portal in town. */ Point PortalTownPosition[MAXPORTAL] = { { 57, 40 }, @@ -29,6 +24,11 @@ Point PortalTownPosition[MAXPORTAL] = { { 63, 40 }, }; +namespace { + +/** Current portal number (a portal array index). */ +size_t portalindex; + } // namespace void InitPortals() diff --git a/Source/portal.h b/Source/portal.h index 30e05f6a8..3bd0981aa 100644 --- a/Source/portal.h +++ b/Source/portal.h @@ -25,6 +25,8 @@ struct Portal { extern Portal Portals[MAXPORTAL]; +extern Point PortalTownPosition[MAXPORTAL]; + void InitPortals(); void SetPortalStats(int i, bool o, Point position, int lvl, dungeon_type lvltype, bool isSetLevel); void AddPortalMissile(const Player &player, Point position, bool sync); diff --git a/Source/stores.cpp b/Source/stores.cpp index 6456d5bd0..c2ac52b49 100644 --- a/Source/stores.cpp +++ b/Source/stores.cpp @@ -52,65 +52,41 @@ Item WitchItems[NumWitchItemsHf]; int BoyItemLevel; Item BoyItem; -namespace { +/** Text lines */ +STextStruct TextLine[NumStoreLines]; /** The current towner being interacted with */ _talker_id TownerId; -/** Is the current dialog full size */ -bool IsTextFullSize; - -/** Number of text lines in the current dialog */ -int NumTextLines; /** Remember currently selected text line from TextLine while displaying a dialog */ int OldTextLine; + +/** Remember current store while displaying a dialog */ +TalkID OldActiveStore; + +/** Remember last scroll position */ +int OldScrollPos; +/** Scroll position */ +int ScrollPos; + /** Currently selected text line from TextLine */ int CurrentTextLine; -struct STextStruct { - enum Type : uint8_t { - Label, - Divider, - Selectable, - }; - - std::string text; - int _sval; - int y; - UiFlags flags; - Type type; - uint8_t _sx; - uint8_t _syoff; - int cursId; - bool cursIndent; - - [[nodiscard]] bool isDivider() const - { - return type == Divider; - } - [[nodiscard]] bool isSelectable() const - { - return type == Selectable; - } +namespace { - [[nodiscard]] bool hasText() const - { - return !text.empty(); - } -}; -/** Text lines */ -STextStruct TextLine[NumStoreLines]; + +/** Is the current dialog full size */ +bool IsTextFullSize; + +/** Number of text lines in the current dialog */ +int NumTextLines; /** Whether to render the player's gold amount in the top left */ bool RenderGold; /** Does the current panel have a scrollbar */ bool HasScrollbar; -/** Remember last scroll position */ -int OldScrollPos; -/** Scroll position */ -int ScrollPos; /** Next scroll position */ int NextScrollPos; /** Previous scroll position */ @@ -120,9 +96,6 @@ int8_t CountdownScrollUp; /** Countdown for the push state of the scroll down button */ int8_t CountdownScrollDown; -/** Remember current store while displaying a dialog */ -TalkID OldActiveStore; - /** Temporary item used to hold the item being traded */ Item TempItem; @@ -335,25 +308,6 @@ void PrintStoreItem(const Item &item, int l, UiFlags flags, bool cursIndent = fa AddSText(40, l++, productLine, flags, false, -1, cursIndent); } -bool StoreAutoPlace(Item &item, bool persistItem) -{ - Player &player = *MyPlayer; - - if (AutoEquipEnabled(player, item) && AutoEquip(player, item, persistItem, true)) { - return true; - } - - if (AutoPlaceItemInBelt(player, item, persistItem, true)) { - return true; - } - - if (persistItem) { - return AutoPlaceItemInInventory(player, item, true); - } - - return CanFitItemInInventory(player, item); -} - void ScrollVendorStore(Item *itemData, int storeLimit, int idx, int selling = true) { ClearSText(5, 21); @@ -402,17 +356,6 @@ void ScrollSmithBuy(int idx) ScrollVendorStore(SmithItems, static_cast(std::size(SmithItems)), idx); } -uint32_t TotalPlayerGold() -{ - return MyPlayer->_pGold + Stash.gold; -} - -// TODO: Change `_iIvalue` to be unsigned instead of passing `int` here. -bool PlayerCanAfford(int price) -{ - return TotalPlayerGold() >= static_cast(price); -} - void StartSmithBuy() { IsTextFullSize = true; @@ -1419,20 +1362,6 @@ void SmithPremiumBuyEnter() StartStore(TalkID::Confirm); } -bool StoreGoldFit(Item &item) -{ - int cost = item._iIvalue; - - Size itemSize = GetInventorySize(item); - int itemRoomForGold = itemSize.width * itemSize.height * MaxGold; - - if (cost <= itemRoomForGold) { - return true; - } - - return cost <= itemRoomForGold + RoomForGold(); -} - /** * @brief Sells an item from the player's inventory or belt. */ @@ -2780,4 +2709,48 @@ bool IsPlayerInStore() return ActiveStore != TalkID::None; } +uint32_t TotalPlayerGold() +{ + return MyPlayer->_pGold + Stash.gold; +} + +// TODO: Change `_iIvalue` to be unsigned instead of passing `int` here. +bool PlayerCanAfford(int price) +{ + return TotalPlayerGold() >= static_cast(price); +} + +bool StoreAutoPlace(Item &item, bool persistItem) +{ + Player &player = *MyPlayer; + + if (AutoEquipEnabled(player, item) && AutoEquip(player, item, persistItem, true)) { + return true; + } + + if (AutoPlaceItemInBelt(player, item, persistItem, true)) { + return true; + } + + if (persistItem) { + return AutoPlaceItemInInventory(player, item, true); + } + + return CanFitItemInInventory(player, item); +} + +bool StoreGoldFit(Item &item) +{ + int cost = item._iIvalue; + + Size itemSize = GetInventorySize(item); + int itemRoomForGold = itemSize.width * itemSize.height * MaxGold; + + if (cost <= itemRoomForGold) { + return true; + } + + return cost <= itemRoomForGold + RoomForGold(); +} + } // namespace devilution diff --git a/Source/stores.h b/Source/stores.h index ea13be716..fc30c26eb 100644 --- a/Source/stores.h +++ b/Source/stores.h @@ -14,6 +14,7 @@ #include "engine/surface.hpp" #include "game_mode.hpp" #include "utils/attributes.h" +#include "towners.h" namespace devilution { @@ -34,6 +35,41 @@ constexpr int NumWitchPinnedItems = 3; constexpr int NumStoreLines = 104; +struct STextStruct { + enum Type : uint8_t { + Label, + Divider, + Selectable, + }; + + std::string text; + int _sval; + int y; + UiFlags flags; + Type type; + uint8_t _sx; + uint8_t _syoff; + int cursId; + bool cursIndent; + + [[nodiscard]] bool isDivider() const + { + return type == Divider; + } + [[nodiscard]] bool isSelectable() const + { + return type == Selectable; + } + + [[nodiscard]] bool hasText() const + { + return !text.empty(); + } +}; + +/** Text lines */ +extern STextStruct TextLine[NumStoreLines]; + enum class TalkID : uint8_t { None, Smith, @@ -91,6 +127,23 @@ extern int BoyItemLevel; /** Current item sold by Wirt */ extern Item BoyItem; +/** The current towner being interacted with */ +extern _talker_id TownerId; + +/** Remember currently selected text line from TextLine while displaying a dialog */ +extern int OldTextLine; + +/** Remember current store while displaying a dialog */ +extern TalkID OldActiveStore; + +/** Remember last scroll position */ +extern int OldScrollPos; +/** Scroll position */ +extern int ScrollPos; + +/** Currently selected text line from TextLine */ +extern int CurrentTextLine; + void AddStoreHoldRepair(Item *itm, int8_t i); /** Clears premium items sold by Griswold and Wirt. */ @@ -117,5 +170,9 @@ void StoreEnter(); void CheckStoreBtn(); void ReleaseStoreBtn(); bool IsPlayerInStore(); +uint32_t TotalPlayerGold(); +bool PlayerCanAfford(int price); +bool StoreAutoPlace(Item &item, bool persistItem); +bool StoreGoldFit(Item &item); } // namespace devilution diff --git a/vcpkg.json b/vcpkg.json index db0e4b14b..efd4a21dd 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -4,7 +4,8 @@ "dependencies": [ "fmt", "bzip2", - "lua" + "lua", + "protobuf" ], "builtin-baseline": "533a5fda5c0646d1771345fb572e759283444d5f", "features": { From 95d1b93bd2c2cab1db708c7ccb436c993acd927a Mon Sep 17 00:00:00 2001 From: Anders Jenbo Date: Fri, 9 May 2025 01:17:10 +0200 Subject: [PATCH 02/32] Fix building on linux and use unchanged SFML --- CMake/Dependencies.cmake | 14 - Source/CMakeLists.txt | 44 +- .../DAPIBackendCore/DAPIProtoClient.cpp | 2 + .../Backend/DAPIBackendCore/DAPIProtoClient.h | 2 +- .../Backend/DAPIBackendCore/SFML/Config.hpp | 183 - .../Backend/DAPIBackendCore/SFML/Network.hpp | 50 - .../SFML/Network/IpAddress.cpp | 219 - .../SFML/Network/IpAddress.hpp | 296 - .../DAPIBackendCore/SFML/Network/Packet.cpp | 476 - .../DAPIBackendCore/SFML/Network/Packet.hpp | 512 - .../DAPIBackendCore/SFML/Network/Socket.cpp | 131 - .../DAPIBackendCore/SFML/Network/Socket.hpp | 211 - .../SFML/Network/SocketHandle.hpp | 54 - .../SFML/Network/SocketImpl.hpp | 38 - .../SFML/Network/SocketSelector.cpp | 188 - .../SFML/Network/SocketSelector.hpp | 255 - .../SFML/Network/TcpListener.cpp | 119 - .../SFML/Network/TcpListener.hpp | 158 - .../SFML/Network/TcpSocket.cpp | 365 - .../SFML/Network/TcpSocket.hpp | 307 - .../SFML/Network/UdpSocket.cpp | 184 - .../SFML/Network/UdpSocket.hpp | 282 - .../SFML/Network/Unix/SocketImpl.hpp | 105 - .../SFML/Network/Unix/SocketImplUnix.cpp | 102 - .../SFML/Network/Win32/SFML_Winsock.hpp | 252 - .../SFML/Network/Win32/SocketImpl.hpp | 108 - .../SFML/Network/Win32/SocketImplWin32.cpp | 167 - .../Backend/Messages/generated/command.pb.cc | 9501 -------------- .../Backend/Messages/generated/command.pb.h | 10429 ---------------- .../Backend/Messages/generated/data.pb.cc | 5512 -------- .../dapi/Backend/Messages/generated/data.pb.h | 6992 ----------- .../Backend/Messages/generated/game.pb.cc | 1115 -- .../dapi/Backend/Messages/generated/game.pb.h | 1609 --- .../Backend/Messages/generated/init.pb.cc | 467 - .../dapi/Backend/Messages/generated/init.pb.h | 466 - .../Backend/Messages/generated/message.pb.cc | 818 -- .../Backend/Messages/generated/message.pb.h | 924 -- Source/dapi/Item.h | 5 +- Source/dapi/Player.h | 6 +- Source/dapi/Server.cpp | 30 +- vcpkg.json | 3 +- 41 files changed, 46 insertions(+), 42655 deletions(-) delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp delete mode 100644 Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp delete mode 100644 Source/dapi/Backend/Messages/generated/command.pb.cc delete mode 100644 Source/dapi/Backend/Messages/generated/command.pb.h delete mode 100644 Source/dapi/Backend/Messages/generated/data.pb.cc delete mode 100644 Source/dapi/Backend/Messages/generated/data.pb.h delete mode 100644 Source/dapi/Backend/Messages/generated/game.pb.cc delete mode 100644 Source/dapi/Backend/Messages/generated/game.pb.h delete mode 100644 Source/dapi/Backend/Messages/generated/init.pb.cc delete mode 100644 Source/dapi/Backend/Messages/generated/init.pb.h delete mode 100644 Source/dapi/Backend/Messages/generated/message.pb.cc delete mode 100644 Source/dapi/Backend/Messages/generated/message.pb.h diff --git a/CMake/Dependencies.cmake b/CMake/Dependencies.cmake index db5e12c52..d99355366 100644 --- a/CMake/Dependencies.cmake +++ b/CMake/Dependencies.cmake @@ -56,20 +56,6 @@ if(SCREEN_READER_INTEGRATION) endif() endif() - - - - -#find_package(Protobuf REQUIRED) -#target_link_libraries(${NAME} PRIVATE protobuf::libprotobuf-lite) -#find_package(Protobuf CONFIG REQUIRED) -#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS "Source/dapi/Backend/Messages/command.proto") -#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/data.proto) -#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/game.proto) -#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/init.proto) -#protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS Source/dapi/Backend/Messages/message.proto) -#target_link_libraries(${NAME} PRIVATE protobuf)#::libprotobuf) - if(EMSCRIPTEN) # We use `USE_PTHREADS=1` here to get a version of SDL2 that supports threads. emscripten_system_library("SDL2" SDL2::SDL2 USE_SDL=2 USE_PTHREADS=1) diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index c180ecfd2..38be7866b 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -642,29 +642,16 @@ if(DISCORD_INTEGRATION) ) endif() -list(APPEND libdevilutionx_SRCS +list(APPEND libdevilutionx_SRCS dapi/Server.cpp dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp - dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp - dapi/Backend/Messages/generated/command.pb.cc - dapi/Backend/Messages/generated/data.pb.cc - dapi/Backend/Messages/generated/game.pb.cc - dapi/Backend/Messages/generated/init.pb.cc - dapi/Backend/Messages/generated/message.pb.cc dapi/Backend/Messages/command.proto dapi/Backend/Messages/data.proto dapi/Backend/Messages/game.proto dapi/Backend/Messages/init.proto dapi/Backend/Messages/message.proto) - if(SCREEN_READER_INTEGRATION) +if(SCREEN_READER_INTEGRATION) list(APPEND libdevilutionx_SRCS utils/screen_reader.cpp ) @@ -816,16 +803,25 @@ find_package(Protobuf REQUIRED) target_link_libraries(libdevilutionx PUBLIC protobuf::libprotobuf-lite) find_package(absl REQUIRED) -set(PROTO_BINARY_DIR "${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/Messages/generated") -target_include_directories(libdevilutionx PUBLIC "$") +set(PROTO_BINARY_DIR "${CMAKE_BINARY_DIR}/generated") + +file(MAKE_DIRECTORY ${PROTO_BINARY_DIR}) + +target_include_directories(libdevilutionx PRIVATE ${Protobuf_INCLUDE_DIRS}) -#this was generating the .pb.cc/.pb.hh files for protobuf messages earlier but breaks in this current setup -#files are already generated at the moment so commenting this allows project to build. -#protobuf_generate( -# TARGET libdevilutionx -# IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/Messages" -# PROTOC_OUT_DIR "${PROTO_BINARY_DIR}") +# Generate the protobuf files into the 'generated' directory within the build tree +protobuf_generate( + TARGET libdevilutionx + IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/Messages" + PROTOC_OUT_DIR "${PROTO_BINARY_DIR}" +) -#include_directories("${CMAKE_CURRENT_SOURCE_DIR}/Source/dapi/Backend/DAPIBackendCore") +# Make sure the generated protobuf files are correctly included in the build +target_include_directories(libdevilutionx PUBLIC "$") +include_directories("${PROTO_BINARY_DIR}/dapi/Backend/Messages") target_include_directories(libdevilutionx PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/DAPIBackendCore") + +find_package(SFML 2.5 REQUIRED network system) + +target_link_libraries(libdevilutionx PUBLIC sfml-network sfml-system) diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp index 7c37e5316..a084e485b 100644 --- a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp @@ -1,3 +1,5 @@ +#include + #include "DAPIProtoClient.h" namespace DAPI { diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h index b5cb2231c..fac6a87dd 100644 --- a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h @@ -6,7 +6,7 @@ #include #pragma warning(push, 0) -#include "..\Messages\generated\message.pb.h" +#include "message.pb.h" #pragma warning(pop) namespace DAPI { diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp deleted file mode 100644 index a85685bb8..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Config.hpp +++ /dev/null @@ -1,183 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_CONFIG_HPP -#define SFML_CONFIG_HPP - -//////////////////////////////////////////////////////////// -// Define the SFML version -//////////////////////////////////////////////////////////// -#define SFML_VERSION_MAJOR 2 -#define SFML_VERSION_MINOR 5 -#define SFML_VERSION_PATCH 1 - -//////////////////////////////////////////////////////////// -// Identify the operating system -// see http://nadeausoftware.com/articles/2012/01/c_c_tip_how_use_compiler_predefined_macros_detect_operating_system -//////////////////////////////////////////////////////////// -#if defined(_WIN32) - -// Windows -#define SFML_SYSTEM_WINDOWS -#ifndef NOMINMAX -#define NOMINMAX -#endif - -#elif defined(__APPLE__) && defined(__MACH__) - -// Apple platform, see which one it is -#include "TargetConditionals.h" - -#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR - -// iOS -#define SFML_SYSTEM_IOS - -#elif TARGET_OS_MAC - -// MacOS -#define SFML_SYSTEM_MACOS - -#else - -// Unsupported Apple system -#error This Apple operating system is not supported by SFML library - -#endif - -#elif defined(__unix__) - -// UNIX system, see which one it is -#if defined(__ANDROID__) - -// Android -#define SFML_SYSTEM_ANDROID - -#elif defined(__linux__) - -// Linux -#define SFML_SYSTEM_LINUX - -#elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) - -// FreeBSD -#define SFML_SYSTEM_FREEBSD - -#elif defined(__OpenBSD__) - -// OpenBSD -#define SFML_SYSTEM_OPENBSD - -#else - -// Unsupported UNIX system -#error This UNIX operating system is not supported by SFML library - -#endif - -#else - -// Unsupported system -#error This operating system is not supported by SFML library - -#endif - -//////////////////////////////////////////////////////////// -// Define a portable debug macro -//////////////////////////////////////////////////////////// -#if !defined(NDEBUG) - -#define SFML_DEBUG - -#endif - -//////////////////////////////////////////////////////////// -// Cross-platform warning for deprecated functions and classes -// -// Usage: -// class SFML_DEPRECATED MyClass -// { -// SFML_DEPRECATED void memberFunc(); -// }; -// -// SFML_DEPRECATED void globalFunc(); -//////////////////////////////////////////////////////////// -#if defined(SFML_NO_DEPRECATED_WARNINGS) - -// User explicitly requests to disable deprecation warnings -#define SFML_DEPRECATED - -#elif defined(_MSC_VER) - -// Microsoft C++ compiler -// Note: On newer MSVC versions, using deprecated functions causes a compiler error. In order to -// trigger a warning instead of an error, the compiler flag /sdl- (instead of /sdl) must be specified. -#define SFML_DEPRECATED __declspec(deprecated) - -#elif defined(__GNUC__) - -// g++ and Clang -#define SFML_DEPRECATED __attribute__((deprecated)) - -#else - -// Other compilers are not supported, leave class or function as-is. -// With a bit of luck, the #pragma directive works, otherwise users get a warning (no error!) for unrecognized #pragma. -#pragma message("SFML_DEPRECATED is not supported for your compiler, please contact the SFML team") -#define SFML_DEPRECATED - -#endif - -//////////////////////////////////////////////////////////// -// Define portable fixed-size types -//////////////////////////////////////////////////////////// -namespace sf { -// All "common" platforms use the same size for char, short and int -// (basically there are 3 types for 3 sizes, so no other match is possible), -// we can use them without doing any kind of check - -// 8 bits integer types -typedef signed char Int8; -typedef unsigned char Uint8; - -// 16 bits integer types -typedef signed short Int16; -typedef unsigned short Uint16; - -// 32 bits integer types -typedef signed int Int32; -typedef unsigned int Uint32; - -// 64 bits integer types -#if defined(_MSC_VER) -typedef signed __int64 Int64; -typedef unsigned __int64 Uint64; -#else -typedef signed long long Int64; -typedef unsigned long long Uint64; -#endif - -} // namespace sf - -#endif // SFML_CONFIG_HPP diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp deleted file mode 100644 index 807e70a66..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network.hpp +++ /dev/null @@ -1,50 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_NETWORK_HPP -#define SFML_NETWORK_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#endif // SFML_NETWORK_HPP - -//////////////////////////////////////////////////////////// -/// \defgroup network Network module -/// -/// Socket-based communication, utilities and higher-level -/// network protocols (HTTP, FTP). -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp deleted file mode 100644 index f9b9af7ae..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.cpp +++ /dev/null @@ -1,219 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -const IpAddress IpAddress::None; -const IpAddress IpAddress::Any(0, 0, 0, 0); -const IpAddress IpAddress::LocalHost(127, 0, 0, 1); -const IpAddress IpAddress::Broadcast(255, 255, 255, 255); - -//////////////////////////////////////////////////////////// -IpAddress::IpAddress() - : m_address(0) - , m_valid(false) -{ -} - -//////////////////////////////////////////////////////////// -IpAddress::IpAddress(const std::string &address) - : m_address(0) - , m_valid(false) -{ - resolve(address); -} - -//////////////////////////////////////////////////////////// -IpAddress::IpAddress(const char *address) - : m_address(0) - , m_valid(false) -{ - resolve(address); -} - -//////////////////////////////////////////////////////////// -IpAddress::IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3) - : m_address(htonl((byte0 << 24) | (byte1 << 16) | (byte2 << 8) | byte3)) - , m_valid(true) -{ -} - -//////////////////////////////////////////////////////////// -IpAddress::IpAddress(Uint32 address) - : m_address(htonl(address)) - , m_valid(true) -{ -} - -//////////////////////////////////////////////////////////// -std::string IpAddress::toString() const -{ - in_addr address; - address.s_addr = m_address; - - return inet_ntoa(address); -} - -//////////////////////////////////////////////////////////// -Uint32 IpAddress::toInteger() const -{ - return ntohl(m_address); -} - -//////////////////////////////////////////////////////////// -IpAddress IpAddress::getLocalAddress() -{ - // The method here is to connect a UDP socket to anyone (here to localhost), - // and get the local socket address with the getsockname function. - // UDP connection will not send anything to the network, so this function won't cause any overhead. - - IpAddress localAddress; - - // Create the socket - SocketHandle sock = socket(PF_INET, SOCK_DGRAM, 0); - if (sock == priv::SocketImpl::invalidSocket()) - return localAddress; - - // Connect the socket to localhost on any port - sockaddr_in address = priv::SocketImpl::createAddress(ntohl(INADDR_LOOPBACK), 9); - if (connect(sock, reinterpret_cast(&address), sizeof(address)) == -1) { - priv::SocketImpl::close(sock); - return localAddress; - } - - // Get the local address of the socket connection - priv::SocketImpl::AddrLength size = sizeof(address); - if (getsockname(sock, reinterpret_cast(&address), &size) == -1) { - priv::SocketImpl::close(sock); - return localAddress; - } - - // Close the socket - priv::SocketImpl::close(sock); - - // Finally build the IP address - localAddress = IpAddress(ntohl(address.sin_addr.s_addr)); - - return localAddress; -} - -//////////////////////////////////////////////////////////// -void IpAddress::resolve(const std::string &address) -{ - m_address = 0; - m_valid = false; - - if (address == "255.255.255.255") { - // The broadcast address needs to be handled explicitly, - // because it is also the value returned by inet_addr on error - m_address = INADDR_BROADCAST; - m_valid = true; - } else if (address == "0.0.0.0") { - m_address = INADDR_ANY; - m_valid = true; - } else { - // Try to convert the address as a byte representation ("xxx.xxx.xxx.xxx") - Uint32 ip = inet_addr(address.c_str()); - if (ip != INADDR_NONE) { - m_address = ip; - m_valid = true; - } else { - // Not a valid address, try to convert it as a host name - addrinfo hints; - std::memset(&hints, 0, sizeof(hints)); - hints.ai_family = AF_INET; - addrinfo *result = NULL; - if (getaddrinfo(address.c_str(), NULL, &hints, &result) == 0) { - if (result) { - ip = reinterpret_cast(result->ai_addr)->sin_addr.s_addr; - freeaddrinfo(result); - m_address = ip; - m_valid = true; - } - } - } - } -} - -//////////////////////////////////////////////////////////// -bool operator==(const IpAddress &left, const IpAddress &right) -{ - return !(left < right) && !(right < left); -} - -//////////////////////////////////////////////////////////// -bool operator!=(const IpAddress &left, const IpAddress &right) -{ - return !(left == right); -} - -//////////////////////////////////////////////////////////// -bool operator<(const IpAddress &left, const IpAddress &right) -{ - return std::make_pair(left.m_valid, left.m_address) < std::make_pair(right.m_valid, right.m_address); -} - -//////////////////////////////////////////////////////////// -bool operator>(const IpAddress &left, const IpAddress &right) -{ - return right < left; -} - -//////////////////////////////////////////////////////////// -bool operator<=(const IpAddress &left, const IpAddress &right) -{ - return !(right < left); -} - -//////////////////////////////////////////////////////////// -bool operator>=(const IpAddress &left, const IpAddress &right) -{ - return !(left < right); -} - -//////////////////////////////////////////////////////////// -std::istream &operator>>(std::istream &stream, IpAddress &address) -{ - std::string str; - stream >> str; - address = IpAddress(str); - - return stream; -} - -//////////////////////////////////////////////////////////// -std::ostream &operator<<(std::ostream &stream, const IpAddress &address) -{ - return stream << address.toString(); -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp deleted file mode 100644 index d6e77ce4d..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/IpAddress.hpp +++ /dev/null @@ -1,296 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_IPADDRESS_HPP -#define SFML_IPADDRESS_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -/// \brief Encapsulate an IPv4 network address -/// -//////////////////////////////////////////////////////////// -class IpAddress { -public: - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - /// This constructor creates an empty (invalid) address - /// - //////////////////////////////////////////////////////////// - IpAddress(); - - //////////////////////////////////////////////////////////// - /// \brief Construct the address from a string - /// - /// Here \a address can be either a decimal address - /// (ex: "192.168.1.56") or a network name (ex: "localhost"). - /// - /// \param address IP address or network name - /// - //////////////////////////////////////////////////////////// - IpAddress(const std::string &address); - - //////////////////////////////////////////////////////////// - /// \brief Construct the address from a string - /// - /// Here \a address can be either a decimal address - /// (ex: "192.168.1.56") or a network name (ex: "localhost"). - /// This is equivalent to the constructor taking a std::string - /// parameter, it is defined for convenience so that the - /// implicit conversions from literal strings to IpAddress work. - /// - /// \param address IP address or network name - /// - //////////////////////////////////////////////////////////// - IpAddress(const char *address); - - //////////////////////////////////////////////////////////// - /// \brief Construct the address from 4 bytes - /// - /// Calling IpAddress(a, b, c, d) is equivalent to calling - /// IpAddress("a.b.c.d"), but safer as it doesn't have to - /// parse a string to get the address components. - /// - /// \param byte0 First byte of the address - /// \param byte1 Second byte of the address - /// \param byte2 Third byte of the address - /// \param byte3 Fourth byte of the address - /// - //////////////////////////////////////////////////////////// - IpAddress(Uint8 byte0, Uint8 byte1, Uint8 byte2, Uint8 byte3); - - //////////////////////////////////////////////////////////// - /// \brief Construct the address from a 32-bits integer - /// - /// This constructor uses the internal representation of - /// the address directly. It should be used for optimization - /// purposes, and only if you got that representation from - /// IpAddress::toInteger(). - /// - /// \param address 4 bytes of the address packed into a 32-bits integer - /// - /// \see toInteger - /// - //////////////////////////////////////////////////////////// - explicit IpAddress(Uint32 address); - - //////////////////////////////////////////////////////////// - /// \brief Get a string representation of the address - /// - /// The returned string is the decimal representation of the - /// IP address (like "192.168.1.56"), even if it was constructed - /// from a host name. - /// - /// \return String representation of the address - /// - /// \see toInteger - /// - //////////////////////////////////////////////////////////// - std::string toString() const; - - //////////////////////////////////////////////////////////// - /// \brief Get an integer representation of the address - /// - /// The returned number is the internal representation of the - /// address, and should be used for optimization purposes only - /// (like sending the address through a socket). - /// The integer produced by this function can then be converted - /// back to a sf::IpAddress with the proper constructor. - /// - /// \return 32-bits unsigned integer representation of the address - /// - /// \see toString - /// - //////////////////////////////////////////////////////////// - Uint32 toInteger() const; - - //////////////////////////////////////////////////////////// - /// \brief Get the computer's local address - /// - /// The local address is the address of the computer from the - /// LAN point of view, i.e. something like 192.168.1.56. It is - /// meaningful only for communications over the local network. - /// Unlike getPublicAddress, this function is fast and may be - /// used safely anywhere. - /// - /// \return Local IP address of the computer - /// - /// \see getPublicAddress - /// - //////////////////////////////////////////////////////////// - static IpAddress getLocalAddress(); - - //////////////////////////////////////////////////////////// - // Static member data - //////////////////////////////////////////////////////////// - static const IpAddress None; ///< Value representing an empty/invalid address - static const IpAddress Any; ///< Value representing any address (0.0.0.0) - static const IpAddress LocalHost; ///< The "localhost" address (for connecting a computer to itself locally) - static const IpAddress Broadcast; ///< The "broadcast" address (for sending UDP messages to everyone on a local network) - -private: - friend bool operator<(const IpAddress &left, const IpAddress &right); - - //////////////////////////////////////////////////////////// - /// \brief Resolve the given address string - /// - /// \param address Address string - /// - //////////////////////////////////////////////////////////// - void resolve(const std::string &address); - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - Uint32 m_address; ///< Address stored as an unsigned 32 bits integer - bool m_valid; ///< Is the address valid? -}; - -//////////////////////////////////////////////////////////// -/// \brief Overload of == operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if both addresses are equal -/// -//////////////////////////////////////////////////////////// -bool operator==(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of != operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if both addresses are different -/// -//////////////////////////////////////////////////////////// -bool operator!=(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of < operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if \a left is lesser than \a right -/// -//////////////////////////////////////////////////////////// -bool operator<(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of > operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if \a left is greater than \a right -/// -//////////////////////////////////////////////////////////// -bool operator>(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of <= operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if \a left is lesser or equal than \a right -/// -//////////////////////////////////////////////////////////// -bool operator<=(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of >= operator to compare two IP addresses -/// -/// \param left Left operand (a IP address) -/// \param right Right operand (a IP address) -/// -/// \return True if \a left is greater or equal than \a right -/// -//////////////////////////////////////////////////////////// -bool operator>=(const IpAddress &left, const IpAddress &right); - -//////////////////////////////////////////////////////////// -/// \brief Overload of >> operator to extract an IP address from an input stream -/// -/// \param stream Input stream -/// \param address IP address to extract -/// -/// \return Reference to the input stream -/// -//////////////////////////////////////////////////////////// -std::istream &operator>>(std::istream &stream, IpAddress &address); - -//////////////////////////////////////////////////////////// -/// \brief Overload of << operator to print an IP address to an output stream -/// -/// \param stream Output stream -/// \param address IP address to print -/// -/// \return Reference to the output stream -/// -//////////////////////////////////////////////////////////// -std::ostream &operator<<(std::ostream &stream, const IpAddress &address); - -} // namespace sf - -#endif // SFML_IPADDRESS_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::IpAddress -/// \ingroup network -/// -/// sf::IpAddress is a utility class for manipulating network -/// addresses. It provides a set a implicit constructors and -/// conversion functions to easily build or transform an IP -/// address from/to various representations. -/// -/// Usage example: -/// \code -/// sf::IpAddress a0; // an invalid address -/// sf::IpAddress a1 = sf::IpAddress::None; // an invalid address (same as a0) -/// sf::IpAddress a2("127.0.0.1"); // the local host address -/// sf::IpAddress a3 = sf::IpAddress::Broadcast; // the broadcast address -/// sf::IpAddress a4(192, 168, 1, 56); // a local address -/// sf::IpAddress a5("my_computer"); // a local address created from a network name -/// sf::IpAddress a6("89.54.1.169"); // a distant address -/// sf::IpAddress a7("www.google.com"); // a distant address created from a network name -/// sf::IpAddress a8 = sf::IpAddress::getLocalAddress(); // my address on the local network -/// sf::IpAddress a9 = sf::IpAddress::getPublicAddress(); // my address on the internet -/// \endcode -/// -/// Note that sf::IpAddress currently doesn't support IPv6 -/// nor other types of network addresses. -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp deleted file mode 100644 index d398b884a..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.cpp +++ /dev/null @@ -1,476 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -Packet::Packet() - : m_readPos(0) - , m_sendPos(0) - , m_isValid(true) -{ -} - -//////////////////////////////////////////////////////////// -Packet::~Packet() -{ -} - -//////////////////////////////////////////////////////////// -void Packet::append(const void *data, std::size_t sizeInBytes) -{ - if (data && (sizeInBytes > 0)) { - std::size_t start = m_data.size(); - m_data.resize(start + sizeInBytes); - std::memcpy(&m_data[start], data, sizeInBytes); - } -} - -//////////////////////////////////////////////////////////// -void Packet::clear() -{ - m_data.clear(); - m_readPos = 0; - m_isValid = true; -} - -//////////////////////////////////////////////////////////// -const void *Packet::getData() const -{ - return !m_data.empty() ? &m_data[0] : NULL; -} - -//////////////////////////////////////////////////////////// -std::size_t Packet::getDataSize() const -{ - return m_data.size(); -} - -//////////////////////////////////////////////////////////// -bool Packet::endOfPacket() const -{ - return m_readPos >= m_data.size(); -} - -//////////////////////////////////////////////////////////// -Packet::operator BoolType() const -{ - return m_isValid ? &Packet::checkSize : NULL; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(bool &data) -{ - Uint8 value; - if (*this >> value) - data = (value != 0); - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Int8 &data) -{ - if (checkSize(sizeof(data))) { - data = *reinterpret_cast(&m_data[m_readPos]); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Uint8 &data) -{ - if (checkSize(sizeof(data))) { - data = *reinterpret_cast(&m_data[m_readPos]); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Int16 &data) -{ - if (checkSize(sizeof(data))) { - data = ntohs(*reinterpret_cast(&m_data[m_readPos])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Uint16 &data) -{ - if (checkSize(sizeof(data))) { - data = ntohs(*reinterpret_cast(&m_data[m_readPos])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Int32 &data) -{ - if (checkSize(sizeof(data))) { - data = ntohl(*reinterpret_cast(&m_data[m_readPos])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Uint32 &data) -{ - if (checkSize(sizeof(data))) { - data = ntohl(*reinterpret_cast(&m_data[m_readPos])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Int64 &data) -{ - if (checkSize(sizeof(data))) { - // Since ntohll is not available everywhere, we have to convert - // to network byte order (big endian) manually - const Uint8 *bytes = reinterpret_cast(&m_data[m_readPos]); - data = (static_cast(bytes[0]) << 56) | (static_cast(bytes[1]) << 48) | (static_cast(bytes[2]) << 40) | (static_cast(bytes[3]) << 32) | (static_cast(bytes[4]) << 24) | (static_cast(bytes[5]) << 16) | (static_cast(bytes[6]) << 8) | (static_cast(bytes[7])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(Uint64 &data) -{ - if (checkSize(sizeof(data))) { - // Since ntohll is not available everywhere, we have to convert - // to network byte order (big endian) manually - const Uint8 *bytes = reinterpret_cast(&m_data[m_readPos]); - data = (static_cast(bytes[0]) << 56) | (static_cast(bytes[1]) << 48) | (static_cast(bytes[2]) << 40) | (static_cast(bytes[3]) << 32) | (static_cast(bytes[4]) << 24) | (static_cast(bytes[5]) << 16) | (static_cast(bytes[6]) << 8) | (static_cast(bytes[7])); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(float &data) -{ - if (checkSize(sizeof(data))) { - data = *reinterpret_cast(&m_data[m_readPos]); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(double &data) -{ - if (checkSize(sizeof(data))) { - data = *reinterpret_cast(&m_data[m_readPos]); - m_readPos += sizeof(data); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(char *data) -{ - // First extract string length - Uint32 length = 0; - *this >> length; - - if ((length > 0) && checkSize(length)) { - // Then extract characters - std::memcpy(data, &m_data[m_readPos], length); - data[length] = '\0'; - - // Update reading position - m_readPos += length; - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(std::string &data) -{ - // First extract string length - Uint32 length = 0; - *this >> length; - - data.clear(); - if ((length > 0) && checkSize(length)) { - // Then extract characters - data.assign(&m_data[m_readPos], length); - - // Update reading position - m_readPos += length; - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(wchar_t *data) -{ - // First extract string length - Uint32 length = 0; - *this >> length; - - if ((length > 0) && checkSize(length * sizeof(Uint32))) { - // Then extract characters - for (Uint32 i = 0; i < length; ++i) { - Uint32 character = 0; - *this >> character; - data[i] = static_cast(character); - } - data[length] = L'\0'; - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator>>(std::wstring &data) -{ - // First extract string length - Uint32 length = 0; - *this >> length; - - data.clear(); - if ((length > 0) && checkSize(length * sizeof(Uint32))) { - // Then extract characters - for (Uint32 i = 0; i < length; ++i) { - Uint32 character = 0; - *this >> character; - data += static_cast(character); - } - } - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(bool data) -{ - *this << static_cast(data); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Int8 data) -{ - append(&data, sizeof(data)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Uint8 data) -{ - append(&data, sizeof(data)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Int16 data) -{ - Int16 toWrite = htons(data); - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Uint16 data) -{ - Uint16 toWrite = htons(data); - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Int32 data) -{ - Int32 toWrite = htonl(data); - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Uint32 data) -{ - Uint32 toWrite = htonl(data); - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Int64 data) -{ - // Since htonll is not available everywhere, we have to convert - // to network byte order (big endian) manually - Uint8 toWrite[] = { - static_cast((data >> 56) & 0xFF), - static_cast((data >> 48) & 0xFF), - static_cast((data >> 40) & 0xFF), - static_cast((data >> 32) & 0xFF), - static_cast((data >> 24) & 0xFF), - static_cast((data >> 16) & 0xFF), - static_cast((data >> 8) & 0xFF), - static_cast((data)&0xFF) - }; - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(Uint64 data) -{ - // Since htonll is not available everywhere, we have to convert - // to network byte order (big endian) manually - Uint8 toWrite[] = { - static_cast((data >> 56) & 0xFF), - static_cast((data >> 48) & 0xFF), - static_cast((data >> 40) & 0xFF), - static_cast((data >> 32) & 0xFF), - static_cast((data >> 24) & 0xFF), - static_cast((data >> 16) & 0xFF), - static_cast((data >> 8) & 0xFF), - static_cast((data)&0xFF) - }; - append(&toWrite, sizeof(toWrite)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(float data) -{ - append(&data, sizeof(data)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(double data) -{ - append(&data, sizeof(data)); - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(const char *data) -{ - // First insert string length - Uint32 length = static_cast(std::strlen(data)); - *this << length; - - // Then insert characters - append(data, length * sizeof(char)); - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(const std::string &data) -{ - // First insert string length - Uint32 length = static_cast(data.size()); - *this << length; - - // Then insert characters - if (length > 0) - append(data.c_str(), length * sizeof(std::string::value_type)); - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(const wchar_t *data) -{ - // First insert string length - Uint32 length = static_cast(std::wcslen(data)); - *this << length; - - // Then insert characters - for (const wchar_t *c = data; *c != L'\0'; ++c) - *this << static_cast(*c); - - return *this; -} - -//////////////////////////////////////////////////////////// -Packet &Packet::operator<<(const std::wstring &data) -{ - // First insert string length - Uint32 length = static_cast(data.size()); - *this << length; - - // Then insert characters - if (length > 0) { - for (std::wstring::const_iterator c = data.begin(); c != data.end(); ++c) - *this << static_cast(*c); - } - - return *this; -} - -//////////////////////////////////////////////////////////// -bool Packet::checkSize(std::size_t size) -{ - m_isValid = m_isValid && (m_readPos + size <= m_data.size()); - - return m_isValid; -} - -//////////////////////////////////////////////////////////// -const void *Packet::onSend(std::size_t &size) -{ - size = getDataSize(); - return getData(); -} - -//////////////////////////////////////////////////////////// -void Packet::onReceive(const void *data, std::size_t size) -{ - append(data, size); -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp deleted file mode 100644 index 16a016cd7..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Packet.hpp +++ /dev/null @@ -1,512 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_PACKET_HPP -#define SFML_PACKET_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include - -namespace sf { -class TcpSocket; -class UdpSocket; - -//////////////////////////////////////////////////////////// -/// \brief Utility class to build blocks of data to transfer -/// over the network -/// -//////////////////////////////////////////////////////////// -class Packet { - // A bool-like type that cannot be converted to integer or pointer types - typedef bool (Packet::*BoolType)(std::size_t); - -public: - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - /// Creates an empty packet. - /// - //////////////////////////////////////////////////////////// - Packet(); - - //////////////////////////////////////////////////////////// - /// \brief Virtual destructor - /// - //////////////////////////////////////////////////////////// - virtual ~Packet(); - - //////////////////////////////////////////////////////////// - /// \brief Append data to the end of the packet - /// - /// \param data Pointer to the sequence of bytes to append - /// \param sizeInBytes Number of bytes to append - /// - /// \see clear - /// - //////////////////////////////////////////////////////////// - void append(const void *data, std::size_t sizeInBytes); - - //////////////////////////////////////////////////////////// - /// \brief Clear the packet - /// - /// After calling Clear, the packet is empty. - /// - /// \see append - /// - //////////////////////////////////////////////////////////// - void clear(); - - //////////////////////////////////////////////////////////// - /// \brief Get a pointer to the data contained in the packet - /// - /// Warning: the returned pointer may become invalid after - /// you append data to the packet, therefore it should never - /// be stored. - /// The return pointer is NULL if the packet is empty. - /// - /// \return Pointer to the data - /// - /// \see getDataSize - /// - //////////////////////////////////////////////////////////// - const void *getData() const; - - //////////////////////////////////////////////////////////// - /// \brief Get the size of the data contained in the packet - /// - /// This function returns the number of bytes pointed to by - /// what getData returns. - /// - /// \return Data size, in bytes - /// - /// \see getData - /// - //////////////////////////////////////////////////////////// - std::size_t getDataSize() const; - - //////////////////////////////////////////////////////////// - /// \brief Tell if the reading position has reached the - /// end of the packet - /// - /// This function is useful to know if there is some data - /// left to be read, without actually reading it. - /// - /// \return True if all data was read, false otherwise - /// - /// \see operator bool - /// - //////////////////////////////////////////////////////////// - bool endOfPacket() const; - -public: - //////////////////////////////////////////////////////////// - /// \brief Test the validity of the packet, for reading - /// - /// This operator allows to test the packet as a boolean - /// variable, to check if a reading operation was successful. - /// - /// A packet will be in an invalid state if it has no more - /// data to read. - /// - /// This behavior is the same as standard C++ streams. - /// - /// Usage example: - /// \code - /// float x; - /// packet >> x; - /// if (packet) - /// { - /// // ok, x was extracted successfully - /// } - /// - /// // -- or -- - /// - /// float x; - /// if (packet >> x) - /// { - /// // ok, x was extracted successfully - /// } - /// \endcode - /// - /// Don't focus on the return type, it's equivalent to bool but - /// it disallows unwanted implicit conversions to integer or - /// pointer types. - /// - /// \return True if last data extraction from packet was successful - /// - /// \see endOfPacket - /// - //////////////////////////////////////////////////////////// - operator BoolType() const; - - //////////////////////////////////////////////////////////// - /// Overload of operator >> to read data from the packet - /// - //////////////////////////////////////////////////////////// - Packet &operator>>(bool &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Int8 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Uint8 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Int16 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Uint16 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Int32 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Uint32 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Int64 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(Uint64 &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(float &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(double &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(char *data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(std::string &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(wchar_t *data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator>>(std::wstring &data); - - //////////////////////////////////////////////////////////// - /// Overload of operator << to write data into the packet - /// - //////////////////////////////////////////////////////////// - Packet &operator<<(bool data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Int8 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Uint8 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Int16 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Uint16 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Int32 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Uint32 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Int64 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(Uint64 data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(float data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(double data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(const char *data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(const std::string &data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(const wchar_t *data); - - //////////////////////////////////////////////////////////// - /// \overload - //////////////////////////////////////////////////////////// - Packet &operator<<(const std::wstring &data); - -protected: - friend class TcpSocket; - friend class UdpSocket; - - //////////////////////////////////////////////////////////// - /// \brief Called before the packet is sent over the network - /// - /// This function can be defined by derived classes to - /// transform the data before it is sent; this can be - /// used for compression, encryption, etc. - /// The function must return a pointer to the modified data, - /// as well as the number of bytes pointed. - /// The default implementation provides the packet's data - /// without transforming it. - /// - /// \param size Variable to fill with the size of data to send - /// - /// \return Pointer to the array of bytes to send - /// - /// \see onReceive - /// - //////////////////////////////////////////////////////////// - virtual const void *onSend(std::size_t &size); - - //////////////////////////////////////////////////////////// - /// \brief Called after the packet is received over the network - /// - /// This function can be defined by derived classes to - /// transform the data after it is received; this can be - /// used for decompression, decryption, etc. - /// The function receives a pointer to the received data, - /// and must fill the packet with the transformed bytes. - /// The default implementation fills the packet directly - /// without transforming the data. - /// - /// \param data Pointer to the received bytes - /// \param size Number of bytes - /// - /// \see onSend - /// - //////////////////////////////////////////////////////////// - virtual void onReceive(const void *data, std::size_t size); - -private: - //////////////////////////////////////////////////////////// - /// Disallow comparisons between packets - /// - //////////////////////////////////////////////////////////// - bool operator==(const Packet &right) const; - bool operator!=(const Packet &right) const; - - //////////////////////////////////////////////////////////// - /// \brief Check if the packet can extract a given number of bytes - /// - /// This function updates accordingly the state of the packet. - /// - /// \param size Size to check - /// - /// \return True if \a size bytes can be read from the packet - /// - //////////////////////////////////////////////////////////// - bool checkSize(std::size_t size); - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - std::vector m_data; ///< Data stored in the packet - std::size_t m_readPos; ///< Current reading position in the packet - std::size_t m_sendPos; ///< Current send position in the packet (for handling partial sends) - bool m_isValid; ///< Reading state of the packet -}; - -} // namespace sf - -#endif // SFML_PACKET_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::Packet -/// \ingroup network -/// -/// Packets provide a safe and easy way to serialize data, -/// in order to send it over the network using sockets -/// (sf::TcpSocket, sf::UdpSocket). -/// -/// Packets solve 2 fundamental problems that arise when -/// transferring data over the network: -/// \li data is interpreted correctly according to the endianness -/// \li the bounds of the packet are preserved (one send == one receive) -/// -/// The sf::Packet class provides both input and output modes. -/// It is designed to follow the behavior of standard C++ streams, -/// using operators >> and << to extract and insert data. -/// -/// It is recommended to use only fixed-size types (like sf::Int32, etc.), -/// to avoid possible differences between the sender and the receiver. -/// Indeed, the native C++ types may have different sizes on two platforms -/// and your data may be corrupted if that happens. -/// -/// Usage example: -/// \code -/// sf::Uint32 x = 24; -/// std::string s = "hello"; -/// double d = 5.89; -/// -/// // Group the variables to send into a packet -/// sf::Packet packet; -/// packet << x << s << d; -/// -/// // Send it over the network (socket is a valid sf::TcpSocket) -/// socket.send(packet); -/// -/// ----------------------------------------------------------------- -/// -/// // Receive the packet at the other end -/// sf::Packet packet; -/// socket.receive(packet); -/// -/// // Extract the variables contained in the packet -/// sf::Uint32 x; -/// std::string s; -/// double d; -/// if (packet >> x >> s >> d) -/// { -/// // Data extracted successfully... -/// } -/// \endcode -/// -/// Packets have built-in operator >> and << overloads for -/// standard types: -/// \li bool -/// \li fixed-size integer types (sf::Int8/16/32, sf::Uint8/16/32) -/// \li floating point numbers (float, double) -/// \li string types (char*, wchar_t*, std::string, std::wstring, sf::String) -/// -/// Like standard streams, it is also possible to define your own -/// overloads of operators >> and << in order to handle your -/// custom types. -/// -/// \code -/// struct MyStruct -/// { -/// float number; -/// sf::Int8 integer; -/// std::string str; -/// }; -/// -/// sf::Packet& operator <<(sf::Packet& packet, const MyStruct& m) -/// { -/// return packet << m.number << m.integer << m.str; -/// } -/// -/// sf::Packet& operator >>(sf::Packet& packet, MyStruct& m) -/// { -/// return packet >> m.number >> m.integer >> m.str; -/// } -/// \endcode -/// -/// Packets also provide an extra feature that allows to apply -/// custom transformations to the data before it is sent, -/// and after it is received. This is typically used to -/// handle automatic compression or encryption of the data. -/// This is achieved by inheriting from sf::Packet, and overriding -/// the onSend and onReceive functions. -/// -/// Here is an example: -/// \code -/// class ZipPacket : public sf::Packet -/// { -/// virtual const void* onSend(std::size_t& size) -/// { -/// const void* srcData = getData(); -/// std::size_t srcSize = getDataSize(); -/// -/// return MySuperZipFunction(srcData, srcSize, &size); -/// } -/// -/// virtual void onReceive(const void* data, std::size_t size) -/// { -/// std::size_t dstSize; -/// const void* dstData = MySuperUnzipFunction(data, size, &dstSize); -/// -/// append(dstData, dstSize); -/// } -/// }; -/// -/// // Use like regular packets: -/// ZipPacket packet; -/// packet << x << s << d; -/// ... -/// \endcode -/// -/// \see sf::TcpSocket, sf::UdpSocket -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp deleted file mode 100644 index dd7a664b6..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.cpp +++ /dev/null @@ -1,131 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -Socket::Socket(Type type) - : m_type(type) - , m_socket(priv::SocketImpl::invalidSocket()) - , m_isBlocking(true) -{ -} - -//////////////////////////////////////////////////////////// -Socket::~Socket() -{ - // Close the socket before it gets destructed - close(); -} - -//////////////////////////////////////////////////////////// -void Socket::setBlocking(bool blocking) -{ - // Apply if the socket is already created - if (m_socket != priv::SocketImpl::invalidSocket()) - priv::SocketImpl::setBlocking(m_socket, blocking); - - m_isBlocking = blocking; -} - -//////////////////////////////////////////////////////////// -bool Socket::isBlocking() const -{ - return m_isBlocking; -} - -//////////////////////////////////////////////////////////// -SocketHandle Socket::getHandle() const -{ - return m_socket; -} - -//////////////////////////////////////////////////////////// -void Socket::create() -{ - // Don't create the socket if it already exists - if (m_socket == priv::SocketImpl::invalidSocket()) { - SocketHandle handle = socket(PF_INET, m_type == Tcp ? SOCK_STREAM : SOCK_DGRAM, 0); - - if (handle == priv::SocketImpl::invalidSocket()) { - std::cerr << "Failed to create socket" << std::endl; - return; - } - - create(handle); - } -} - -//////////////////////////////////////////////////////////// -void Socket::create(SocketHandle handle) -{ - // Don't create the socket if it already exists - if (m_socket == priv::SocketImpl::invalidSocket()) { - // Assign the new handle - m_socket = handle; - - // Set the current blocking state - setBlocking(m_isBlocking); - - if (m_type == Tcp) { - // Disable the Nagle algorithm (i.e. removes buffering of TCP packets) - int yes = 1; - if (setsockopt(m_socket, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast(&yes), sizeof(yes)) == -1) { - std::cerr << "Failed to set socket option \"TCP_NODELAY\" ; " - << "all your TCP packets will be buffered" << std::endl; - } - -// On Mac OS X, disable the SIGPIPE signal on disconnection -#ifdef SFML_SYSTEM_MACOS - if (setsockopt(m_socket, SOL_SOCKET, SO_NOSIGPIPE, reinterpret_cast(&yes), sizeof(yes)) == -1) { - std::cerr << "Failed to set socket option \"SO_NOSIGPIPE\"" << std::endl; - } -#endif - } else { - // Enable broadcast by default for UDP sockets - int yes = 1; - if (setsockopt(m_socket, SOL_SOCKET, SO_BROADCAST, reinterpret_cast(&yes), sizeof(yes)) == -1) { - std::cerr << "Failed to enable broadcast on UDP socket" << std::endl; - } - } - } -} - -//////////////////////////////////////////////////////////// -void Socket::close() -{ - // Close the socket - if (m_socket != priv::SocketImpl::invalidSocket()) { - priv::SocketImpl::close(m_socket); - m_socket = priv::SocketImpl::invalidSocket(); - } -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp deleted file mode 100644 index 801c05301..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Socket.hpp +++ /dev/null @@ -1,211 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_SOCKET_HPP -#define SFML_SOCKET_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include - -namespace sf { -class SocketSelector; - -//////////////////////////////////////////////////////////// -/// \brief Base class for all the socket types -/// -//////////////////////////////////////////////////////////// -class Socket { -public: - //////////////////////////////////////////////////////////// - /// \brief Status codes that may be returned by socket functions - /// - //////////////////////////////////////////////////////////// - enum Status { - Done, ///< The socket has sent / received the data - NotReady, ///< The socket is not ready to send / receive data yet - Partial, ///< The socket sent a part of the data - Disconnected, ///< The TCP socket has been disconnected - Error ///< An unexpected error happened - }; - - //////////////////////////////////////////////////////////// - /// \brief Some special values used by sockets - /// - //////////////////////////////////////////////////////////// - enum { - AnyPort = 0 ///< Special value that tells the system to pick any available port - }; - -public: - //////////////////////////////////////////////////////////// - /// \brief Destructor - /// - //////////////////////////////////////////////////////////// - virtual ~Socket(); - - // NonCopyable - Socket(const Socket &) = delete; - Socket(Socket &&) = delete; - Socket &operator=(const Socket &) = delete; - Socket &operator=(Socket &&) = delete; - - //////////////////////////////////////////////////////////// - /// \brief Set the blocking state of the socket - /// - /// In blocking mode, calls will not return until they have - /// completed their task. For example, a call to Receive in - /// blocking mode won't return until some data was actually - /// received. - /// In non-blocking mode, calls will always return immediately, - /// using the return code to signal whether there was data - /// available or not. - /// By default, all sockets are blocking. - /// - /// \param blocking True to set the socket as blocking, false for non-blocking - /// - /// \see isBlocking - /// - //////////////////////////////////////////////////////////// - void setBlocking(bool blocking); - - //////////////////////////////////////////////////////////// - /// \brief Tell whether the socket is in blocking or non-blocking mode - /// - /// \return True if the socket is blocking, false otherwise - /// - /// \see setBlocking - /// - //////////////////////////////////////////////////////////// - bool isBlocking() const; - -protected: - //////////////////////////////////////////////////////////// - /// \brief Types of protocols that the socket can use - /// - //////////////////////////////////////////////////////////// - enum Type { - Tcp, ///< TCP protocol - Udp ///< UDP protocol - }; - - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - /// This constructor can only be accessed by derived classes. - /// - /// \param type Type of the socket (TCP or UDP) - /// - //////////////////////////////////////////////////////////// - Socket(Type type); - - //////////////////////////////////////////////////////////// - /// \brief Return the internal handle of the socket - /// - /// The returned handle may be invalid if the socket - /// was not created yet (or already destroyed). - /// This function can only be accessed by derived classes. - /// - /// \return The internal (OS-specific) handle of the socket - /// - //////////////////////////////////////////////////////////// - SocketHandle getHandle() const; - - //////////////////////////////////////////////////////////// - /// \brief Create the internal representation of the socket - /// - /// This function can only be accessed by derived classes. - /// - //////////////////////////////////////////////////////////// - void create(); - - //////////////////////////////////////////////////////////// - /// \brief Create the internal representation of the socket - /// from a socket handle - /// - /// This function can only be accessed by derived classes. - /// - /// \param handle OS-specific handle of the socket to wrap - /// - //////////////////////////////////////////////////////////// - void create(SocketHandle handle); - - //////////////////////////////////////////////////////////// - /// \brief Close the socket gracefully - /// - /// This function can only be accessed by derived classes. - /// - //////////////////////////////////////////////////////////// - void close(); - -private: - friend class SocketSelector; - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - Type m_type; ///< Type of the socket (TCP or UDP) - SocketHandle m_socket; ///< Socket descriptor - bool m_isBlocking; ///< Current blocking mode of the socket -}; - -} // namespace sf - -#endif // SFML_SOCKET_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::Socket -/// \ingroup network -/// -/// This class mainly defines internal stuff to be used by -/// derived classes. -/// -/// The only public features that it defines, and which -/// is therefore common to all the socket classes, is the -/// blocking state. All sockets can be set as blocking or -/// non-blocking. -/// -/// In blocking mode, socket functions will hang until -/// the operation completes, which means that the entire -/// program (well, in fact the current thread if you use -/// multiple ones) will be stuck waiting for your socket -/// operation to complete. -/// -/// In non-blocking mode, all the socket functions will -/// return immediately. If the socket is not ready to complete -/// the requested operation, the function simply returns -/// the proper status code (Socket::NotReady). -/// -/// The default mode, which is blocking, is the one that is -/// generally used, in combination with threads or selectors. -/// The non-blocking mode is rather used in real-time -/// applications that run an endless loop that can poll -/// the socket often enough, and cannot afford blocking -/// this loop. -/// -/// \see sf::TcpListener, sf::TcpSocket, sf::UdpSocket -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp deleted file mode 100644 index a49fe9009..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketHandle.hpp +++ /dev/null @@ -1,54 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_SOCKETHANDLE_HPP -#define SFML_SOCKETHANDLE_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include - -#if defined(SFML_SYSTEM_WINDOWS) -#include -#endif - -namespace sf { -//////////////////////////////////////////////////////////// -// Define the low-level socket handle type, specific to -// each platform -//////////////////////////////////////////////////////////// -#if defined(SFML_SYSTEM_WINDOWS) - -typedef UINT_PTR SocketHandle; - -#else - -typedef int SocketHandle; - -#endif - -} // namespace sf - -#endif // SFML_SOCKETHANDLE_HPP diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp deleted file mode 100644 index 72ab62e4c..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketImpl.hpp +++ /dev/null @@ -1,38 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include - -#if defined(SFML_SYSTEM_WINDOWS) - -#include - -#else - -#include - -#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp deleted file mode 100644 index 35bc5adf8..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.cpp +++ /dev/null @@ -1,188 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include -#include - -#ifdef _MSC_VER -#pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro -#endif - -namespace sf { -//////////////////////////////////////////////////////////// -struct SocketSelector::SocketSelectorImpl { - fd_set allSockets; ///< Set containing all the sockets handles - fd_set socketsReady; ///< Set containing handles of the sockets that are ready - int maxSocket; ///< Maximum socket handle - int socketCount; ///< Number of socket handles -}; - -//////////////////////////////////////////////////////////// -SocketSelector::SocketSelector() - : m_impl(new SocketSelectorImpl) -{ - clear(); -} - -//////////////////////////////////////////////////////////// -SocketSelector::SocketSelector(const SocketSelector ©) - : m_impl(new SocketSelectorImpl(*copy.m_impl)) -{ -} - -//////////////////////////////////////////////////////////// -SocketSelector::~SocketSelector() -{ - delete m_impl; -} - -//////////////////////////////////////////////////////////// -void SocketSelector::add(Socket &socket) -{ - SocketHandle handle = socket.getHandle(); - if (handle != priv::SocketImpl::invalidSocket()) { - -#if defined(SFML_SYSTEM_WINDOWS) - - if (m_impl->socketCount >= FD_SETSIZE) { - std::cerr << "The socket can't be added to the selector because the " - << "selector is full. This is a limitation of your operating " - << "system's FD_SETSIZE setting."; - return; - } - - if (FD_ISSET(handle, &m_impl->allSockets)) - return; - - m_impl->socketCount++; - -#else - - if (handle >= FD_SETSIZE) { - std::cerr << "The socket can't be added to the selector because its " - << "ID is too high. This is a limitation of your operating " - << "system's FD_SETSIZE setting."; - return; - } - - // SocketHandle is an int in POSIX - m_impl->maxSocket = std::max(m_impl->maxSocket, handle); - -#endif - - FD_SET(handle, &m_impl->allSockets); - } -} - -//////////////////////////////////////////////////////////// -void SocketSelector::remove(Socket &socket) -{ - SocketHandle handle = socket.getHandle(); - if (handle != priv::SocketImpl::invalidSocket()) { - -#if defined(SFML_SYSTEM_WINDOWS) - - if (!FD_ISSET(handle, &m_impl->allSockets)) - return; - - m_impl->socketCount--; - -#else - - if (handle >= FD_SETSIZE) - return; - -#endif - - FD_CLR(handle, &m_impl->allSockets); - FD_CLR(handle, &m_impl->socketsReady); - } -} - -//////////////////////////////////////////////////////////// -void SocketSelector::clear() -{ - FD_ZERO(&m_impl->allSockets); - FD_ZERO(&m_impl->socketsReady); - - m_impl->maxSocket = 0; - m_impl->socketCount = 0; -} - -//////////////////////////////////////////////////////////// -bool SocketSelector::wait(std::chrono::microseconds timeout) -{ - // Setup the timeout - timeval time; - time.tv_sec = static_cast(std::chrono::duration_cast(timeout).count()); - time.tv_usec = static_cast(std::chrono::duration_cast(timeout).count()); - - // Initialize the set that will contain the sockets that are ready - m_impl->socketsReady = m_impl->allSockets; - - // Wait until one of the sockets is ready for reading, or timeout is reached - // The first parameter is ignored on Windows - int count = select(m_impl->maxSocket + 1, &m_impl->socketsReady, NULL, NULL, timeout != std::chrono::microseconds::zero() ? &time : NULL); - - return count > 0; -} - -//////////////////////////////////////////////////////////// -bool SocketSelector::isReady(Socket &socket) const -{ - SocketHandle handle = socket.getHandle(); - if (handle != priv::SocketImpl::invalidSocket()) { - -#if !defined(SFML_SYSTEM_WINDOWS) - - if (handle >= FD_SETSIZE) - return false; - -#endif - - return FD_ISSET(handle, &m_impl->socketsReady) != 0; - } - - return false; -} - -//////////////////////////////////////////////////////////// -SocketSelector &SocketSelector::operator=(const SocketSelector &right) -{ - SocketSelector temp(right); - - std::swap(m_impl, temp.m_impl); - - return *this; -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp deleted file mode 100644 index cb796e99a..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/SocketSelector.hpp +++ /dev/null @@ -1,255 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_SOCKETSELECTOR_HPP -#define SFML_SOCKETSELECTOR_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include - -namespace sf { -class Socket; - -//////////////////////////////////////////////////////////// -/// \brief Multiplexer that allows to read from multiple sockets -/// -//////////////////////////////////////////////////////////// -class SocketSelector { -public: - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - //////////////////////////////////////////////////////////// - SocketSelector(); - - //////////////////////////////////////////////////////////// - /// \brief Copy constructor - /// - /// \param copy Instance to copy - /// - //////////////////////////////////////////////////////////// - SocketSelector(const SocketSelector ©); - - //////////////////////////////////////////////////////////// - /// \brief Destructor - /// - //////////////////////////////////////////////////////////// - ~SocketSelector(); - - //////////////////////////////////////////////////////////// - /// \brief Add a new socket to the selector - /// - /// This function keeps a weak reference to the socket, - /// so you have to make sure that the socket is not destroyed - /// while it is stored in the selector. - /// This function does nothing if the socket is not valid. - /// - /// \param socket Reference to the socket to add - /// - /// \see remove, clear - /// - //////////////////////////////////////////////////////////// - void add(Socket &socket); - - //////////////////////////////////////////////////////////// - /// \brief Remove a socket from the selector - /// - /// This function doesn't destroy the socket, it simply - /// removes the reference that the selector has to it. - /// - /// \param socket Reference to the socket to remove - /// - /// \see add, clear - /// - //////////////////////////////////////////////////////////// - void remove(Socket &socket); - - //////////////////////////////////////////////////////////// - /// \brief Remove all the sockets stored in the selector - /// - /// This function doesn't destroy any instance, it simply - /// removes all the references that the selector has to - /// external sockets. - /// - /// \see add, remove - /// - //////////////////////////////////////////////////////////// - void clear(); - - //////////////////////////////////////////////////////////// - /// \brief Wait until one or more sockets are ready to receive - /// - /// This function returns as soon as at least one socket has - /// some data available to be received. To know which sockets are - /// ready, use the isReady function. - /// If you use a timeout and no socket is ready before the timeout - /// is over, the function returns false. - /// - /// \param timeout Maximum time to wait, (use Time::Zero for infinity) - /// - /// \return True if there are sockets ready, false otherwise - /// - /// \see isReady - /// - //////////////////////////////////////////////////////////// - bool wait(std::chrono::microseconds timeout = std::chrono::microseconds::zero()); - - //////////////////////////////////////////////////////////// - /// \brief Test a socket to know if it is ready to receive data - /// - /// This function must be used after a call to Wait, to know - /// which sockets are ready to receive data. If a socket is - /// ready, a call to receive will never block because we know - /// that there is data available to read. - /// Note that if this function returns true for a TcpListener, - /// this means that it is ready to accept a new connection. - /// - /// \param socket Socket to test - /// - /// \return True if the socket is ready to read, false otherwise - /// - /// \see isReady - /// - //////////////////////////////////////////////////////////// - bool isReady(Socket &socket) const; - - //////////////////////////////////////////////////////////// - /// \brief Overload of assignment operator - /// - /// \param right Instance to assign - /// - /// \return Reference to self - /// - //////////////////////////////////////////////////////////// - SocketSelector &operator=(const SocketSelector &right); - -private: - struct SocketSelectorImpl; - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - SocketSelectorImpl *m_impl; ///< Opaque pointer to the implementation (which requires OS-specific types) -}; - -} // namespace sf - -#endif // SFML_SOCKETSELECTOR_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::SocketSelector -/// \ingroup network -/// -/// Socket selectors provide a way to wait until some data is -/// available on a set of sockets, instead of just one. This -/// is convenient when you have multiple sockets that may -/// possibly receive data, but you don't know which one will -/// be ready first. In particular, it avoids to use a thread -/// for each socket; with selectors, a single thread can handle -/// all the sockets. -/// -/// All types of sockets can be used in a selector: -/// \li sf::TcpListener -/// \li sf::TcpSocket -/// \li sf::UdpSocket -/// -/// A selector doesn't store its own copies of the sockets -/// (socket classes are not copyable anyway), it simply keeps -/// a reference to the original sockets that you pass to the -/// "add" function. Therefore, you can't use the selector as a -/// socket container, you must store them outside and make sure -/// that they are alive as long as they are used in the selector. -/// -/// Using a selector is simple: -/// \li populate the selector with all the sockets that you want to observe -/// \li make it wait until there is data available on any of the sockets -/// \li test each socket to find out which ones are ready -/// -/// Usage example: -/// \code -/// // Create a socket to listen to new connections -/// sf::TcpListener listener; -/// listener.listen(55001); -/// -/// // Create a list to store the future clients -/// std::list clients; -/// -/// // Create a selector -/// sf::SocketSelector selector; -/// -/// // Add the listener to the selector -/// selector.add(listener); -/// -/// // Endless loop that waits for new connections -/// while (running) -/// { -/// // Make the selector wait for data on any socket -/// if (selector.wait()) -/// { -/// // Test the listener -/// if (selector.isReady(listener)) -/// { -/// // The listener is ready: there is a pending connection -/// sf::TcpSocket* client = new sf::TcpSocket; -/// if (listener.accept(*client) == sf::Socket::Done) -/// { -/// // Add the new client to the clients list -/// clients.push_back(client); -/// -/// // Add the new client to the selector so that we will -/// // be notified when he sends something -/// selector.add(*client); -/// } -/// else -/// { -/// // Error, we won't get a new connection, delete the socket -/// delete client; -/// } -/// } -/// else -/// { -/// // The listener socket is not ready, test all other sockets (the clients) -/// for (std::list::iterator it = clients.begin(); it != clients.end(); ++it) -/// { -/// sf::TcpSocket& client = **it; -/// if (selector.isReady(client)) -/// { -/// // The client has sent some data, we can receive it -/// sf::Packet packet; -/// if (client.receive(packet) == sf::Socket::Done) -/// { -/// ... -/// } -/// } -/// } -/// } -/// } -/// } -/// \endcode -/// -/// \see sf::Socket -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp deleted file mode 100644 index d86a6e3bf..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.cpp +++ /dev/null @@ -1,119 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -TcpListener::TcpListener() - : Socket(Tcp) -{ -} - -//////////////////////////////////////////////////////////// -unsigned short TcpListener::getLocalPort() const -{ - if (getHandle() != priv::SocketImpl::invalidSocket()) { - // Retrieve informations about the local end of the socket - sockaddr_in address; - priv::SocketImpl::AddrLength size = sizeof(address); - if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { - return ntohs(address.sin_port); - } - } - - // We failed to retrieve the port - return 0; -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpListener::listen(unsigned short port, const IpAddress &address) -{ - // Close the socket if it is already bound - close(); - - // Create the internal socket if it doesn't exist - create(); - - // Check if the address is valid - if ((address == IpAddress::None) || (address == IpAddress::Broadcast)) - return Error; - - // Bind the socket to the specified port - sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port); - if (bind(getHandle(), reinterpret_cast(&addr), sizeof(addr)) == -1) { - // Not likely to happen, but... - std::cerr << "Failed to bind listener socket to port " << port << std::endl; - return Error; - } - - // Listen to the bound port - if (::listen(getHandle(), SOMAXCONN) == -1) { - // Oops, socket is deaf - std::cerr << "Failed to listen to port " << port << std::endl; - return Error; - } - - return Done; -} - -//////////////////////////////////////////////////////////// -void TcpListener::close() -{ - // Simply close the socket - Socket::close(); -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpListener::accept(TcpSocket &socket) -{ - // Make sure that we're listening - if (getHandle() == priv::SocketImpl::invalidSocket()) { - std::cerr << "Failed to accept a new connection, the socket is not listening" << std::endl; - return Error; - } - - // Accept a new connection - sockaddr_in address; - priv::SocketImpl::AddrLength length = sizeof(address); - SocketHandle remote = ::accept(getHandle(), reinterpret_cast(&address), &length); - - // Check for errors - if (remote == priv::SocketImpl::invalidSocket()) - return priv::SocketImpl::getErrorStatus(); - - // Initialize the new connected socket - socket.close(); - socket.create(remote); - - return Done; -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp deleted file mode 100644 index d4c386311..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpListener.hpp +++ /dev/null @@ -1,158 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_TCPLISTENER_HPP -#define SFML_TCPLISTENER_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include - -namespace sf { -class TcpSocket; - -//////////////////////////////////////////////////////////// -/// \brief Socket that listens to new TCP connections -/// -//////////////////////////////////////////////////////////// -class TcpListener : public Socket { -public: - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - //////////////////////////////////////////////////////////// - TcpListener(); - - //////////////////////////////////////////////////////////// - /// \brief Get the port to which the socket is bound locally - /// - /// If the socket is not listening to a port, this function - /// returns 0. - /// - /// \return Port to which the socket is bound - /// - /// \see listen - /// - //////////////////////////////////////////////////////////// - unsigned short getLocalPort() const; - - //////////////////////////////////////////////////////////// - /// \brief Start listening for incoming connection attempts - /// - /// This function makes the socket start listening on the - /// specified port, waiting for incoming connection attempts. - /// - /// If the socket is already listening on a port when this - /// function is called, it will stop listening on the old - /// port before starting to listen on the new port. - /// - /// \param port Port to listen on for incoming connection attempts - /// \param address Address of the interface to listen on - /// - /// \return Status code - /// - /// \see accept, close - /// - //////////////////////////////////////////////////////////// - Status listen(unsigned short port, const IpAddress &address = IpAddress::Any); - - //////////////////////////////////////////////////////////// - /// \brief Stop listening and close the socket - /// - /// This function gracefully stops the listener. If the - /// socket is not listening, this function has no effect. - /// - /// \see listen - /// - //////////////////////////////////////////////////////////// - void close(); - - //////////////////////////////////////////////////////////// - /// \brief Accept a new connection - /// - /// If the socket is in blocking mode, this function will - /// not return until a connection is actually received. - /// - /// \param socket Socket that will hold the new connection - /// - /// \return Status code - /// - /// \see listen - /// - //////////////////////////////////////////////////////////// - Status accept(TcpSocket &socket); -}; - -} // namespace sf - -#endif // SFML_TCPLISTENER_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::TcpListener -/// \ingroup network -/// -/// A listener socket is a special type of socket that listens to -/// a given port and waits for connections on that port. -/// This is all it can do. -/// -/// When a new connection is received, you must call accept and -/// the listener returns a new instance of sf::TcpSocket that -/// is properly initialized and can be used to communicate with -/// the new client. -/// -/// Listener sockets are specific to the TCP protocol, -/// UDP sockets are connectionless and can therefore communicate -/// directly. As a consequence, a listener socket will always -/// return the new connections as sf::TcpSocket instances. -/// -/// A listener is automatically closed on destruction, like all -/// other types of socket. However if you want to stop listening -/// before the socket is destroyed, you can call its close() -/// function. -/// -/// Usage example: -/// \code -/// // Create a listener socket and make it wait for new -/// // connections on port 55001 -/// sf::TcpListener listener; -/// listener.listen(55001); -/// -/// // Endless loop that waits for new connections -/// while (running) -/// { -/// sf::TcpSocket client; -/// if (listener.accept(client) == sf::Socket::Done) -/// { -/// // A new client just connected! -/// std::cout << "New connection received from " << client.getRemoteAddress() << std::endl; -/// doSomethingWith(client); -/// } -/// } -/// \endcode -/// -/// \see sf::TcpSocket, sf::Socket -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp deleted file mode 100644 index c3a033899..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.cpp +++ /dev/null @@ -1,365 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include -#include - -#ifdef _MSC_VER -#pragma warning(disable : 4127) // "conditional expression is constant" generated by the FD_SET macro -#endif - -namespace { -// Define the low-level send/receive flags, which depend on the OS -#ifdef SFML_SYSTEM_LINUX -const int flags = MSG_NOSIGNAL; -#else -const int flags = 0; -#endif -} // namespace - -namespace sf { -//////////////////////////////////////////////////////////// -TcpSocket::TcpSocket() - : Socket(Tcp) -{ -} - -//////////////////////////////////////////////////////////// -unsigned short TcpSocket::getLocalPort() const -{ - if (getHandle() != priv::SocketImpl::invalidSocket()) { - // Retrieve informations about the local end of the socket - sockaddr_in address; - priv::SocketImpl::AddrLength size = sizeof(address); - if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { - return ntohs(address.sin_port); - } - } - - // We failed to retrieve the port - return 0; -} - -//////////////////////////////////////////////////////////// -IpAddress TcpSocket::getRemoteAddress() const -{ - if (getHandle() != priv::SocketImpl::invalidSocket()) { - // Retrieve informations about the remote end of the socket - sockaddr_in address; - priv::SocketImpl::AddrLength size = sizeof(address); - if (getpeername(getHandle(), reinterpret_cast(&address), &size) != -1) { - return IpAddress(ntohl(address.sin_addr.s_addr)); - } - } - - // We failed to retrieve the address - return IpAddress::None; -} - -//////////////////////////////////////////////////////////// -unsigned short TcpSocket::getRemotePort() const -{ - if (getHandle() != priv::SocketImpl::invalidSocket()) { - // Retrieve informations about the remote end of the socket - sockaddr_in address; - priv::SocketImpl::AddrLength size = sizeof(address); - if (getpeername(getHandle(), reinterpret_cast(&address), &size) != -1) { - return ntohs(address.sin_port); - } - } - - // We failed to retrieve the port - return 0; -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::connect(const IpAddress &remoteAddress, unsigned short remotePort, std::chrono::microseconds timeout) -{ - // Disconnect the socket if it is already connected - disconnect(); - - // Create the internal socket if it doesn't exist - create(); - - // Create the remote address - sockaddr_in address = priv::SocketImpl::createAddress(remoteAddress.toInteger(), remotePort); - - if (timeout <= std::chrono::microseconds::zero()) { - // ----- We're not using a timeout: just try to connect ----- - - // Connect the socket - if (::connect(getHandle(), reinterpret_cast(&address), sizeof(address)) == -1) - return priv::SocketImpl::getErrorStatus(); - - // Connection succeeded - return Done; - } else { - // ----- We're using a timeout: we'll need a few tricks to make it work ----- - - // Save the previous blocking state - bool blocking = isBlocking(); - - // Switch to non-blocking to enable our connection timeout - if (blocking) - setBlocking(false); - - // Try to connect to the remote address - if (::connect(getHandle(), reinterpret_cast(&address), sizeof(address)) >= 0) { - // We got instantly connected! (it may no happen a lot...) - setBlocking(blocking); - return Done; - } - - // Get the error status - Status status = priv::SocketImpl::getErrorStatus(); - - // If we were in non-blocking mode, return immediately - if (!blocking) - return status; - - // Otherwise, wait until something happens to our socket (success, timeout or error) - if (status == Socket::NotReady) { - // Setup the selector - fd_set selector; - FD_ZERO(&selector); - FD_SET(getHandle(), &selector); - - // Setup the timeout - timeval time; - time.tv_sec = static_cast(std::chrono::duration_cast(timeout).count()); - time.tv_usec = static_cast(std::chrono::duration_cast(timeout).count()); - - // Wait for something to write on our socket (which means that the connection request has returned) - if (select(static_cast(getHandle() + 1), NULL, &selector, NULL, &time) > 0) { - // At this point the connection may have been either accepted or refused. - // To know whether it's a success or a failure, we must check the address of the connected peer - if (getRemoteAddress() != IpAddress::None) { - // Connection accepted - status = Done; - } else { - // Connection refused - status = priv::SocketImpl::getErrorStatus(); - } - } else { - // Failed to connect before timeout is over - status = priv::SocketImpl::getErrorStatus(); - } - } - - // Switch back to blocking mode - setBlocking(true); - - return status; - } -} - -//////////////////////////////////////////////////////////// -void TcpSocket::disconnect() -{ - // Close the socket - close(); - - // Reset the pending packet data - m_pendingPacket = PendingPacket(); -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::send(const void *data, std::size_t size) -{ - if (!isBlocking()) - std::cerr << "Warning: Partial sends might not be handled properly." << std::endl; - - std::size_t sent; - - return send(data, size, sent); -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::send(const void *data, std::size_t size, std::size_t &sent) -{ - // Check the parameters - if (!data || (size == 0)) { - std::cerr << "Cannot send data over the network (no data to send)" << std::endl; - return Error; - } - - // Loop until every byte has been sent - int result = 0; - for (sent = 0; sent < size; sent += result) { - // Send a chunk of data - result = ::send(getHandle(), static_cast(data) + sent, static_cast(size - sent), flags); - - // Check for errors - if (result < 0) { - Status status = priv::SocketImpl::getErrorStatus(); - - if ((status == NotReady) && sent) - return Partial; - - return status; - } - } - - return Done; -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::receive(void *data, std::size_t size, std::size_t &received) -{ - // First clear the variables to fill - received = 0; - - // Check the destination buffer - if (!data) { - std::cerr << "Cannot receive data from the network (the destination buffer is invalid)" << std::endl; - return Error; - } - - // Receive a chunk of bytes - int sizeReceived = recv(getHandle(), static_cast(data), static_cast(size), flags); - - // Check the number of bytes received - if (sizeReceived > 0) { - received = static_cast(sizeReceived); - return Done; - } else if (sizeReceived == 0) { - return Socket::Disconnected; - } else { - return priv::SocketImpl::getErrorStatus(); - } -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::send(Packet &packet) -{ - // TCP is a stream protocol, it doesn't preserve messages boundaries. - // This means that we have to send the packet size first, so that the - // receiver knows the actual end of the packet in the data stream. - - // We allocate an extra memory block so that the size can be sent - // together with the data in a single call. This may seem inefficient, - // but it is actually required to avoid partial send, which could cause - // data corruption on the receiving end. - - // Get the data to send from the packet - std::size_t size = 0; - const void *data = packet.onSend(size); - - // First convert the packet size to network byte order - Uint32 packetSize = htonl(static_cast(size)); - - // Allocate memory for the data block to send - std::vector blockToSend(sizeof(packetSize) + size); - - // Copy the packet size and data into the block to send - std::memcpy(&blockToSend[0], &packetSize, sizeof(packetSize)); - if (size > 0) - std::memcpy(&blockToSend[0] + sizeof(packetSize), data, size); - - // Send the data block - std::size_t sent; - Status status = send(&blockToSend[0] + packet.m_sendPos, blockToSend.size() - packet.m_sendPos, sent); - - // In the case of a partial send, record the location to resume from - if (status == Partial) { - packet.m_sendPos += sent; - } else if (status == Done) { - packet.m_sendPos = 0; - } - - return status; -} - -//////////////////////////////////////////////////////////// -Socket::Status TcpSocket::receive(Packet &packet) -{ - // First clear the variables to fill - packet.clear(); - - // We start by getting the size of the incoming packet - Uint32 packetSize = 0; - std::size_t received = 0; - if (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { - // Loop until we've received the entire size of the packet - // (even a 4 byte variable may be received in more than one call) - while (m_pendingPacket.SizeReceived < sizeof(m_pendingPacket.Size)) { - char *data = reinterpret_cast(&m_pendingPacket.Size) + m_pendingPacket.SizeReceived; - Status status = receive(data, sizeof(m_pendingPacket.Size) - m_pendingPacket.SizeReceived, received); - m_pendingPacket.SizeReceived += received; - - if (status != Done) - return status; - } - - // The packet size has been fully received - packetSize = ntohl(m_pendingPacket.Size); - } else { - // The packet size has already been received in a previous call - packetSize = ntohl(m_pendingPacket.Size); - } - - // Loop until we receive all the packet data - char buffer[1024]; - while (m_pendingPacket.Data.size() < packetSize) { - // Receive a chunk of data - std::size_t sizeToGet = std::min(static_cast(packetSize - m_pendingPacket.Data.size()), sizeof(buffer)); - Status status = receive(buffer, sizeToGet, received); - if (status != Done) - return status; - - // Append it into the packet - if (received > 0) { - m_pendingPacket.Data.resize(m_pendingPacket.Data.size() + received); - char *begin = &m_pendingPacket.Data[0] + m_pendingPacket.Data.size() - received; - std::memcpy(begin, buffer, received); - } - } - - // We have received all the packet data: we can copy it to the user packet - if (!m_pendingPacket.Data.empty()) - packet.onReceive(&m_pendingPacket.Data[0], m_pendingPacket.Data.size()); - - // Clear the pending packet data - m_pendingPacket = PendingPacket(); - - return Done; -} - -//////////////////////////////////////////////////////////// -TcpSocket::PendingPacket::PendingPacket() - : Size(0) - , SizeReceived(0) - , Data() -{ -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp deleted file mode 100644 index ab74ee4fe..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/TcpSocket.hpp +++ /dev/null @@ -1,307 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_TCPSOCKET_HPP -#define SFML_TCPSOCKET_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include - -namespace sf { -class TcpListener; -class IpAddress; -class Packet; - -//////////////////////////////////////////////////////////// -/// \brief Specialized socket using the TCP protocol -/// -//////////////////////////////////////////////////////////// -class TcpSocket : public Socket { -public: - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - //////////////////////////////////////////////////////////// - TcpSocket(); - - //////////////////////////////////////////////////////////// - /// \brief Get the port to which the socket is bound locally - /// - /// If the socket is not connected, this function returns 0. - /// - /// \return Port to which the socket is bound - /// - /// \see connect, getRemotePort - /// - //////////////////////////////////////////////////////////// - unsigned short getLocalPort() const; - - //////////////////////////////////////////////////////////// - /// \brief Get the address of the connected peer - /// - /// It the socket is not connected, this function returns - /// sf::IpAddress::None. - /// - /// \return Address of the remote peer - /// - /// \see getRemotePort - /// - //////////////////////////////////////////////////////////// - IpAddress getRemoteAddress() const; - - //////////////////////////////////////////////////////////// - /// \brief Get the port of the connected peer to which - /// the socket is connected - /// - /// If the socket is not connected, this function returns 0. - /// - /// \return Remote port to which the socket is connected - /// - /// \see getRemoteAddress - /// - //////////////////////////////////////////////////////////// - unsigned short getRemotePort() const; - - //////////////////////////////////////////////////////////// - /// \brief Connect the socket to a remote peer - /// - /// In blocking mode, this function may take a while, especially - /// if the remote peer is not reachable. The last parameter allows - /// you to stop trying to connect after a given timeout. - /// If the socket is already connected, the connection is - /// forcibly disconnected before attempting to connect again. - /// - /// \param remoteAddress Address of the remote peer - /// \param remotePort Port of the remote peer - /// \param timeout Optional maximum time to wait - /// - /// \return Status code - /// - /// \see disconnect - /// - //////////////////////////////////////////////////////////// - Status connect(const IpAddress &remoteAddress, unsigned short remotePort, std::chrono::microseconds timeout = std::chrono::microseconds::zero()); - - //////////////////////////////////////////////////////////// - /// \brief Disconnect the socket from its remote peer - /// - /// This function gracefully closes the connection. If the - /// socket is not connected, this function has no effect. - /// - /// \see connect - /// - //////////////////////////////////////////////////////////// - void disconnect(); - - //////////////////////////////////////////////////////////// - /// \brief Send raw data to the remote peer - /// - /// To be able to handle partial sends over non-blocking - /// sockets, use the send(const void*, std::size_t, std::size_t&) - /// overload instead. - /// This function will fail if the socket is not connected. - /// - /// \param data Pointer to the sequence of bytes to send - /// \param size Number of bytes to send - /// - /// \return Status code - /// - /// \see receive - /// - //////////////////////////////////////////////////////////// - Status send(const void *data, std::size_t size); - - //////////////////////////////////////////////////////////// - /// \brief Send raw data to the remote peer - /// - /// This function will fail if the socket is not connected. - /// - /// \param data Pointer to the sequence of bytes to send - /// \param size Number of bytes to send - /// \param sent The number of bytes sent will be written here - /// - /// \return Status code - /// - /// \see receive - /// - //////////////////////////////////////////////////////////// - Status send(const void *data, std::size_t size, std::size_t &sent); - - //////////////////////////////////////////////////////////// - /// \brief Receive raw data from the remote peer - /// - /// In blocking mode, this function will wait until some - /// bytes are actually received. - /// This function will fail if the socket is not connected. - /// - /// \param data Pointer to the array to fill with the received bytes - /// \param size Maximum number of bytes that can be received - /// \param received This variable is filled with the actual number of bytes received - /// - /// \return Status code - /// - /// \see send - /// - //////////////////////////////////////////////////////////// - Status receive(void *data, std::size_t size, std::size_t &received); - - //////////////////////////////////////////////////////////// - /// \brief Send a formatted packet of data to the remote peer - /// - /// In non-blocking mode, if this function returns sf::Socket::Partial, - /// you \em must retry sending the same unmodified packet before sending - /// anything else in order to guarantee the packet arrives at the remote - /// peer uncorrupted. - /// This function will fail if the socket is not connected. - /// - /// \param packet Packet to send - /// - /// \return Status code - /// - /// \see receive - /// - //////////////////////////////////////////////////////////// - Status send(Packet &packet); - - //////////////////////////////////////////////////////////// - /// \brief Receive a formatted packet of data from the remote peer - /// - /// In blocking mode, this function will wait until the whole packet - /// has been received. - /// This function will fail if the socket is not connected. - /// - /// \param packet Packet to fill with the received data - /// - /// \return Status code - /// - /// \see send - /// - //////////////////////////////////////////////////////////// - Status receive(Packet &packet); - -private: - friend class TcpListener; - - //////////////////////////////////////////////////////////// - /// \brief Structure holding the data of a pending packet - /// - //////////////////////////////////////////////////////////// - struct PendingPacket { - PendingPacket(); - - Uint32 Size; ///< Data of packet size - std::size_t SizeReceived; ///< Number of size bytes received so far - std::vector Data; ///< Data of the packet - }; - - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - PendingPacket m_pendingPacket; ///< Temporary data of the packet currently being received -}; - -} // namespace sf - -#endif // SFML_TCPSOCKET_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::TcpSocket -/// \ingroup network -/// -/// TCP is a connected protocol, which means that a TCP -/// socket can only communicate with the host it is connected -/// to. It can't send or receive anything if it is not connected. -/// -/// The TCP protocol is reliable but adds a slight overhead. -/// It ensures that your data will always be received in order -/// and without errors (no data corrupted, lost or duplicated). -/// -/// When a socket is connected to a remote host, you can -/// retrieve informations about this host with the -/// getRemoteAddress and getRemotePort functions. You can -/// also get the local port to which the socket is bound -/// (which is automatically chosen when the socket is connected), -/// with the getLocalPort function. -/// -/// Sending and receiving data can use either the low-level -/// or the high-level functions. The low-level functions -/// process a raw sequence of bytes, and cannot ensure that -/// one call to Send will exactly match one call to Receive -/// at the other end of the socket. -/// -/// The high-level interface uses packets (see sf::Packet), -/// which are easier to use and provide more safety regarding -/// the data that is exchanged. You can look at the sf::Packet -/// class to get more details about how they work. -/// -/// The socket is automatically disconnected when it is destroyed, -/// but if you want to explicitly close the connection while -/// the socket instance is still alive, you can call disconnect. -/// -/// Usage example: -/// \code -/// // ----- The client ----- -/// -/// // Create a socket and connect it to 192.168.1.50 on port 55001 -/// sf::TcpSocket socket; -/// socket.connect("192.168.1.50", 55001); -/// -/// // Send a message to the connected host -/// std::string message = "Hi, I am a client"; -/// socket.send(message.c_str(), message.size() + 1); -/// -/// // Receive an answer from the server -/// char buffer[1024]; -/// std::size_t received = 0; -/// socket.receive(buffer, sizeof(buffer), received); -/// std::cout << "The server said: " << buffer << std::endl; -/// -/// // ----- The server ----- -/// -/// // Create a listener to wait for incoming connections on port 55001 -/// sf::TcpListener listener; -/// listener.listen(55001); -/// -/// // Wait for a connection -/// sf::TcpSocket socket; -/// listener.accept(socket); -/// std::cout << "New client connected: " << socket.getRemoteAddress() << std::endl; -/// -/// // Receive a message from the client -/// char buffer[1024]; -/// std::size_t received = 0; -/// socket.receive(buffer, sizeof(buffer), received); -/// std::cout << "The client said: " << buffer << std::endl; -/// -/// // Send an answer -/// std::string message = "Welcome, client"; -/// socket.send(message.c_str(), message.size() + 1); -/// \endcode -/// -/// \see sf::Socket, sf::UdpSocket, sf::Packet -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp deleted file mode 100644 index 16976bbad..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.cpp +++ /dev/null @@ -1,184 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include - -namespace sf { -//////////////////////////////////////////////////////////// -UdpSocket::UdpSocket() - : Socket(Udp) - , m_buffer(MaxDatagramSize) -{ -} - -//////////////////////////////////////////////////////////// -unsigned short UdpSocket::getLocalPort() const -{ - if (getHandle() != priv::SocketImpl::invalidSocket()) { - // Retrieve informations about the local end of the socket - sockaddr_in address; - priv::SocketImpl::AddrLength size = sizeof(address); - if (getsockname(getHandle(), reinterpret_cast(&address), &size) != -1) { - return ntohs(address.sin_port); - } - } - - // We failed to retrieve the port - return 0; -} - -//////////////////////////////////////////////////////////// -Socket::Status UdpSocket::bind(unsigned short port, const IpAddress &address) -{ - // Close the socket if it is already bound - close(); - - // Create the internal socket if it doesn't exist - create(); - - // Check if the address is valid - if ((address == IpAddress::None) || (address == IpAddress::Broadcast)) - return Error; - - // Bind the socket - sockaddr_in addr = priv::SocketImpl::createAddress(address.toInteger(), port); - if (::bind(getHandle(), reinterpret_cast(&addr), sizeof(addr)) == -1) { - std::cerr << "Failed to bind socket to port " << port << std::endl; - return Error; - } - - return Done; -} - -//////////////////////////////////////////////////////////// -void UdpSocket::unbind() -{ - // Simply close the socket - close(); -} - -//////////////////////////////////////////////////////////// -Socket::Status UdpSocket::send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort) -{ - // Create the internal socket if it doesn't exist - create(); - - // Make sure that all the data will fit in one datagram - if (size > MaxDatagramSize) { - std::cerr << "Cannot send data over the network " - << "(the number of bytes to send is greater than sf::UdpSocket::MaxDatagramSize)" << std::endl; - return Error; - } - - // Build the target address - sockaddr_in address = priv::SocketImpl::createAddress(remoteAddress.toInteger(), remotePort); - - // Send the data (unlike TCP, all the data is always sent in one call) - int sent = sendto(getHandle(), static_cast(data), static_cast(size), 0, reinterpret_cast(&address), sizeof(address)); - - // Check for errors - if (sent < 0) - return priv::SocketImpl::getErrorStatus(); - - return Done; -} - -//////////////////////////////////////////////////////////// -Socket::Status UdpSocket::receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort) -{ - // First clear the variables to fill - received = 0; - remoteAddress = IpAddress(); - remotePort = 0; - - // Check the destination buffer - if (!data) { - std::cerr << "Cannot receive data from the network (the destination buffer is invalid)" << std::endl; - return Error; - } - - // Data that will be filled with the other computer's address - sockaddr_in address = priv::SocketImpl::createAddress(INADDR_ANY, 0); - - // Receive a chunk of bytes - priv::SocketImpl::AddrLength addressSize = sizeof(address); - int sizeReceived = recvfrom(getHandle(), static_cast(data), static_cast(size), 0, reinterpret_cast(&address), &addressSize); - - // Check for errors - if (sizeReceived < 0) - return priv::SocketImpl::getErrorStatus(); - - // Fill the sender informations - received = static_cast(sizeReceived); - remoteAddress = IpAddress(ntohl(address.sin_addr.s_addr)); - remotePort = ntohs(address.sin_port); - - return Done; -} - -//////////////////////////////////////////////////////////// -Socket::Status UdpSocket::send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort) -{ - // UDP is a datagram-oriented protocol (as opposed to TCP which is a stream protocol). - // Sending one datagram is almost safe: it may be lost but if it's received, then its data - // is guaranteed to be ok. However, splitting a packet into multiple datagrams would be highly - // unreliable, since datagrams may be reordered, dropped or mixed between different sources. - // That's why SFML imposes a limit on packet size so that they can be sent in a single datagram. - // This also removes the overhead associated to packets -- there's no size to send in addition - // to the packet's data. - - // Get the data to send from the packet - std::size_t size = 0; - const void *data = packet.onSend(size); - - // Send it - return send(data, size, remoteAddress, remotePort); -} - -//////////////////////////////////////////////////////////// -Socket::Status UdpSocket::receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort) -{ - // See the detailed comment in send(Packet) above. - - // Receive the datagram - std::size_t received = 0; - Status status = receive(&m_buffer[0], m_buffer.size(), received, remoteAddress, remotePort); - - // If we received valid data, we can copy it to the user packet - packet.clear(); - if ((status == Done) && (received > 0)) - packet.onReceive(&m_buffer[0], received); - - return status; -} - -} // namespace sf diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp deleted file mode 100644 index dbb71b7c0..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/UdpSocket.hpp +++ /dev/null @@ -1,282 +0,0 @@ -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_UDPSOCKET_HPP -#define SFML_UDPSOCKET_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include - -namespace sf { -class Packet; - -//////////////////////////////////////////////////////////// -/// \brief Specialized socket using the UDP protocol -/// -//////////////////////////////////////////////////////////// -class UdpSocket : public Socket { -public: - //////////////////////////////////////////////////////////// - // Constants - //////////////////////////////////////////////////////////// - enum { - MaxDatagramSize = 65507 ///< The maximum number of bytes that can be sent in a single UDP datagram - }; - - //////////////////////////////////////////////////////////// - /// \brief Default constructor - /// - //////////////////////////////////////////////////////////// - UdpSocket(); - - //////////////////////////////////////////////////////////// - /// \brief Get the port to which the socket is bound locally - /// - /// If the socket is not bound to a port, this function - /// returns 0. - /// - /// \return Port to which the socket is bound - /// - /// \see bind - /// - //////////////////////////////////////////////////////////// - unsigned short getLocalPort() const; - - //////////////////////////////////////////////////////////// - /// \brief Bind the socket to a specific port - /// - /// Binding the socket to a port is necessary for being - /// able to receive data on that port. - /// You can use the special value Socket::AnyPort to tell the - /// system to automatically pick an available port, and then - /// call getLocalPort to retrieve the chosen port. - /// - /// Since the socket can only be bound to a single port at - /// any given moment, if it is already bound when this - /// function is called, it will be unbound from the previous - /// port before being bound to the new one. - /// - /// \param port Port to bind the socket to - /// \param address Address of the interface to bind to - /// - /// \return Status code - /// - /// \see unbind, getLocalPort - /// - //////////////////////////////////////////////////////////// - Status bind(unsigned short port, const IpAddress &address = IpAddress::Any); - - //////////////////////////////////////////////////////////// - /// \brief Unbind the socket from the local port to which it is bound - /// - /// The port that the socket was previously bound to is immediately - /// made available to the operating system after this function is called. - /// This means that a subsequent call to bind() will be able to re-bind - /// the port if no other process has done so in the mean time. - /// If the socket is not bound to a port, this function has no effect. - /// - /// \see bind - /// - //////////////////////////////////////////////////////////// - void unbind(); - - //////////////////////////////////////////////////////////// - /// \brief Send raw data to a remote peer - /// - /// Make sure that \a size is not greater than - /// UdpSocket::MaxDatagramSize, otherwise this function will - /// fail and no data will be sent. - /// - /// \param data Pointer to the sequence of bytes to send - /// \param size Number of bytes to send - /// \param remoteAddress Address of the receiver - /// \param remotePort Port of the receiver to send the data to - /// - /// \return Status code - /// - /// \see receive - /// - //////////////////////////////////////////////////////////// - Status send(const void *data, std::size_t size, const IpAddress &remoteAddress, unsigned short remotePort); - - //////////////////////////////////////////////////////////// - /// \brief Receive raw data from a remote peer - /// - /// In blocking mode, this function will wait until some - /// bytes are actually received. - /// Be careful to use a buffer which is large enough for - /// the data that you intend to receive, if it is too small - /// then an error will be returned and *all* the data will - /// be lost. - /// - /// \param data Pointer to the array to fill with the received bytes - /// \param size Maximum number of bytes that can be received - /// \param received This variable is filled with the actual number of bytes received - /// \param remoteAddress Address of the peer that sent the data - /// \param remotePort Port of the peer that sent the data - /// - /// \return Status code - /// - /// \see send - /// - //////////////////////////////////////////////////////////// - Status receive(void *data, std::size_t size, std::size_t &received, IpAddress &remoteAddress, unsigned short &remotePort); - - //////////////////////////////////////////////////////////// - /// \brief Send a formatted packet of data to a remote peer - /// - /// Make sure that the packet size is not greater than - /// UdpSocket::MaxDatagramSize, otherwise this function will - /// fail and no data will be sent. - /// - /// \param packet Packet to send - /// \param remoteAddress Address of the receiver - /// \param remotePort Port of the receiver to send the data to - /// - /// \return Status code - /// - /// \see receive - /// - //////////////////////////////////////////////////////////// - Status send(Packet &packet, const IpAddress &remoteAddress, unsigned short remotePort); - - //////////////////////////////////////////////////////////// - /// \brief Receive a formatted packet of data from a remote peer - /// - /// In blocking mode, this function will wait until the whole packet - /// has been received. - /// - /// \param packet Packet to fill with the received data - /// \param remoteAddress Address of the peer that sent the data - /// \param remotePort Port of the peer that sent the data - /// - /// \return Status code - /// - /// \see send - /// - //////////////////////////////////////////////////////////// - Status receive(Packet &packet, IpAddress &remoteAddress, unsigned short &remotePort); - -private: - //////////////////////////////////////////////////////////// - // Member data - //////////////////////////////////////////////////////////// - std::vector m_buffer; ///< Temporary buffer holding the received data in Receive(Packet) -}; - -} // namespace sf - -#endif // SFML_UDPSOCKET_HPP - -//////////////////////////////////////////////////////////// -/// \class sf::UdpSocket -/// \ingroup network -/// -/// A UDP socket is a connectionless socket. Instead of -/// connecting once to a remote host, like TCP sockets, -/// it can send to and receive from any host at any time. -/// -/// It is a datagram protocol: bounded blocks of data (datagrams) -/// are transfered over the network rather than a continuous -/// stream of data (TCP). Therefore, one call to send will always -/// match one call to receive (if the datagram is not lost), -/// with the same data that was sent. -/// -/// The UDP protocol is lightweight but unreliable. Unreliable -/// means that datagrams may be duplicated, be lost or -/// arrive reordered. However, if a datagram arrives, its -/// data is guaranteed to be valid. -/// -/// UDP is generally used for real-time communication -/// (audio or video streaming, real-time games, etc.) where -/// speed is crucial and lost data doesn't matter much. -/// -/// Sending and receiving data can use either the low-level -/// or the high-level functions. The low-level functions -/// process a raw sequence of bytes, whereas the high-level -/// interface uses packets (see sf::Packet), which are easier -/// to use and provide more safety regarding the data that is -/// exchanged. You can look at the sf::Packet class to get -/// more details about how they work. -/// -/// It is important to note that UdpSocket is unable to send -/// datagrams bigger than MaxDatagramSize. In this case, it -/// returns an error and doesn't send anything. This applies -/// to both raw data and packets. Indeed, even packets are -/// unable to split and recompose data, due to the unreliability -/// of the protocol (dropped, mixed or duplicated datagrams may -/// lead to a big mess when trying to recompose a packet). -/// -/// If the socket is bound to a port, it is automatically -/// unbound from it when the socket is destroyed. However, -/// you can unbind the socket explicitly with the Unbind -/// function if necessary, to stop receiving messages or -/// make the port available for other sockets. -/// -/// Usage example: -/// \code -/// // ----- The client ----- -/// -/// // Create a socket and bind it to the port 55001 -/// sf::UdpSocket socket; -/// socket.bind(55001); -/// -/// // Send a message to 192.168.1.50 on port 55002 -/// std::string message = "Hi, I am " + sf::IpAddress::getLocalAddress().toString(); -/// socket.send(message.c_str(), message.size() + 1, "192.168.1.50", 55002); -/// -/// // Receive an answer (most likely from 192.168.1.50, but could be anyone else) -/// char buffer[1024]; -/// std::size_t received = 0; -/// sf::IpAddress sender; -/// unsigned short port; -/// socket.receive(buffer, sizeof(buffer), received, sender, port); -/// std::cout << sender.ToString() << " said: " << buffer << std::endl; -/// -/// // ----- The server ----- -/// -/// // Create a socket and bind it to the port 55002 -/// sf::UdpSocket socket; -/// socket.bind(55002); -/// -/// // Receive a message from anyone -/// char buffer[1024]; -/// std::size_t received = 0; -/// sf::IpAddress sender; -/// unsigned short port; -/// socket.receive(buffer, sizeof(buffer), received, sender, port); -/// std::cout << sender.ToString() << " said: " << buffer << std::endl; -/// -/// // Send an answer -/// std::string message = "Welcome " + sender.toString(); -/// socket.send(message.c_str(), message.size() + 1, sender, port); -/// \endcode -/// -/// \see sf::Socket, sf::TcpSocket, sf::Packet -/// -//////////////////////////////////////////////////////////// diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp deleted file mode 100644 index d33cc7b27..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImpl.hpp +++ /dev/null @@ -1,105 +0,0 @@ -#ifndef _WIN32 -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_SOCKETIMPL_HPP -#define SFML_SOCKETIMPL_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include -#include -#include -#include - -namespace sf { -namespace priv { -//////////////////////////////////////////////////////////// -/// \brief Helper class implementing all the non-portable -/// socket stuff; this is the Unix version -/// -//////////////////////////////////////////////////////////// -class SocketImpl { -public: - //////////////////////////////////////////////////////////// - // Types - //////////////////////////////////////////////////////////// - typedef socklen_t AddrLength; - - //////////////////////////////////////////////////////////// - /// \brief Create an internal sockaddr_in address - /// - /// \param address Target address - /// \param port Target port - /// - /// \return sockaddr_in ready to be used by socket functions - /// - //////////////////////////////////////////////////////////// - static sockaddr_in createAddress(Uint32 address, unsigned short port); - - //////////////////////////////////////////////////////////// - /// \brief Return the value of the invalid socket - /// - /// \return Special value of the invalid socket - /// - //////////////////////////////////////////////////////////// - static SocketHandle invalidSocket(); - - //////////////////////////////////////////////////////////// - /// \brief Close and destroy a socket - /// - /// \param sock Handle of the socket to close - /// - //////////////////////////////////////////////////////////// - static void close(SocketHandle sock); - - //////////////////////////////////////////////////////////// - /// \brief Set a socket as blocking or non-blocking - /// - /// \param sock Handle of the socket - /// \param block New blocking state of the socket - /// - //////////////////////////////////////////////////////////// - static void setBlocking(SocketHandle sock, bool block); - - //////////////////////////////////////////////////////////// - /// Get the last socket error status - /// - /// \return Status corresponding to the last socket error - /// - //////////////////////////////////////////////////////////// - static Socket::Status getErrorStatus(); -}; - -} // namespace priv - -} // namespace sf - -#endif // SFML_SOCKETIMPL_HPP -#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp deleted file mode 100644 index f37cef7b7..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Unix/SocketImplUnix.cpp +++ /dev/null @@ -1,102 +0,0 @@ -#ifndef _WIN32 -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include -#include -#include -#include - -namespace sf { -namespace priv { -//////////////////////////////////////////////////////////// -sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) -{ - sockaddr_in addr; - std::memset(&addr, 0, sizeof(addr)); - addr.sin_addr.s_addr = htonl(address); - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - -#if defined(SFML_SYSTEM_MACOS) - addr.sin_len = sizeof(addr); -#endif - - return addr; -} - -//////////////////////////////////////////////////////////// -SocketHandle SocketImpl::invalidSocket() -{ - return -1; -} - -//////////////////////////////////////////////////////////// -void SocketImpl::close(SocketHandle sock) -{ - ::close(sock); -} - -//////////////////////////////////////////////////////////// -void SocketImpl::setBlocking(SocketHandle sock, bool block) -{ - int status = fcntl(sock, F_GETFL); - if (block) { - if (fcntl(sock, F_SETFL, status & ~O_NONBLOCK) == -1) - std::cerr << "Failed to set file status flags: " << errno << std::endl; - } else { - if (fcntl(sock, F_SETFL, status | O_NONBLOCK) == -1) - std::cerr << "Failed to set file status flags: " << errno << std::endl; - } -} - -//////////////////////////////////////////////////////////// -Socket::Status SocketImpl::getErrorStatus() -{ - // The followings are sometimes equal to EWOULDBLOCK, - // so we have to make a special case for them in order - // to avoid having double values in the switch case - if ((errno == EAGAIN) || (errno == EINPROGRESS)) - return Socket::NotReady; - - switch (errno) { - case EWOULDBLOCK: return Socket::NotReady; - case ECONNABORTED: return Socket::Disconnected; - case ECONNRESET: return Socket::Disconnected; - case ETIMEDOUT: return Socket::Disconnected; - case ENETRESET: return Socket::Disconnected; - case ENOTCONN: return Socket::Disconnected; - case EPIPE: return Socket::Disconnected; - default: return Socket::Error; - } -} - -} // namespace priv - -} // namespace sf -#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp deleted file mode 100644 index 25ef1b227..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SFML_Winsock.hpp +++ /dev/null @@ -1,252 +0,0 @@ -#ifndef WIN32_LEAN_AND_MEAN -#define WIN32_LEAN_AND_MEAN -#endif - -#ifndef NOGDICAPMASKS -#define NOGDICAPMASKS -#endif - -#ifndef NOVIRTUALKEYCODES -#define NOVIRTUALKEYCODES -#endif - -#ifndef NOWINMESSAGES -#define NOWINMESSAGES -#endif - -#ifndef NOWINSTYLES -#define NOWINSTYLES -#endif - -#ifndef NOSYSMETRICS -#define NOSYSMETRICS -#endif - -#ifndef NOMENUS -#define NOMENUS -#endif - -#ifndef NOICONS -#define NOICONS -#endif - -#ifndef NOKEYSTATES -#define NOKEYSTATES -#endif - -#ifndef NOSYSCOMMANDS -#define NOSYSCOMMANDS -#endif - -#ifndef NORASTEROPS -#define NORASTEROPS -#endif - -#ifndef NOSHOWWINDOW -#define NOSHOWWINDOW -#endif - -#ifndef NOATOM -#define NOATOM -#endif - -#ifndef NOCLIPBOARD -#define NOCLIPBOARD -#endif - -#ifndef NOCOLOR -#define NOCOLOR -#endif - -#ifndef NOCTLMGR -#define NOCTLMGR -#endif - -#ifndef NODRAWTEXT -#define NODRAWTEXT -#endif - -#ifndef NOGDI -#define NOGDI -#endif - -#ifndef NOKERNEL -#define NOKERNEL -#endif - -#ifndef NOUSER -#define NOUSER -#endif - -#ifndef NONLS -#define NONLS -#endif - -#ifndef NOMB -#define NOMB -#endif - -#ifndef NOMEMMGR -#define NOMEMMGR -#endif - -#ifndef NOMETAFILE -#define NOMETAFILE -#endif - -#ifndef NOMINMAX -#define NOMINMAX -#endif - -#ifndef NOMSG -#define NOMSG -#endif - -#ifndef NOOPENFILE -#define NOOPENFILE -#endif - -#ifndef NOSCROLL -#define NOSCROLL -#endif - -#ifndef NOSERVICE -#define NOSERVICE -#endif - -#ifndef NOSOUND -#define NOSOUND -#endif - -#ifndef NOTEXTMETRIC -#define NOTEXTMETRIC -#endif - -#ifndef NOWH -#define NOWH -#endif - -#ifndef NOWINOFFSETS -#define NOWINOFFSETS -#endif - -#ifndef NOCOMM -#define NOCOMM -#endif - -#ifndef NOKANJI -#define NOKANJI -#endif - -#ifndef NOHELP -#define NOHELP -#endif - -#ifndef NOPROFILER -#define NOPROFILER -#endif - -#ifndef NODEFERWINDOWPOS -#define NODEFERWINDOWPOS -#endif - -#ifndef NOMCX -#define NOMCX -#endif - -#ifndef _WINSOCK_DEPRECATED_NO_WARNINGS -#define _WINSOCK_DEPRECATED_NO_WARNINGS -#endif - -#define recvfrom recvfrom_original -#define setsockopt setsockopt_original -#define socket socket_original -#define select select_original -#define WSAGetLastError WSAGetLastError_original -#define ioctlsocket ioctlsocket_original -#define htons htons_original -#define htonl htonl_original -#define WSAStartup WSAStartup_original -#define closesocket closesocket_original -#define WSACleanup WSACleanup_original -#define ntohs ntohs_original -#define getsockname getsockname_original -#define listen listen_original -#define bind bind_original -#define accept accept_original -#define ntohl ntohl_original -#define recv recv_original -#define connect connect_original -#define send send_original -#define getpeername getpeername_original -#define freeaddrinfo freeaddrinfo_original -#define inet_ntoa inet_ntoa_original -#define inet_addr inet_addr_original -#define getaddrinfo getaddrinfo_original -#define sendto sendto_original -#define __WSAFDIsSet __WSAFDIsSet_original - -#include -#include - -#undef recvfrom -#undef setsockopt -#undef socket -#undef select -#undef WSAGetLastError -#undef ioctlsocket -#undef htons -#undef htonl -#undef WSAStartup -#undef closesocket -#undef WSACleanup -#undef ntohs -#undef getsockname -#undef listen -#undef bind -#undef accept -#undef ntohl -#undef recv -#undef connect -#undef send -#undef getpeername -#undef freeaddrinfo -#undef inet_ntoa -#undef inet_addr -#undef getaddrinfo -#undef sendto -#undef __WSAFDIsSet - -extern decltype(recvfrom_original) *recvfrom; -extern decltype(setsockopt_original) *setsockopt; -extern decltype(socket_original) *socket; -extern decltype(select_original) *select; -extern decltype(WSAGetLastError_original) *WSAGetLastError; -extern decltype(ioctlsocket_original) *ioctlsocket; -extern decltype(htons_original) *htons; -extern decltype(htonl_original) *htonl; -extern decltype(WSAStartup_original) *WSAStartup; -extern decltype(closesocket_original) *closesocket; -extern decltype(WSACleanup_original) *WSACleanup; -extern decltype(ntohs_original) *ntohs; -extern decltype(getsockname_original) *getsockname; -extern decltype(listen_original) *listen; -extern decltype(bind_original) *bind; -extern decltype(accept_original) *accept; -extern decltype(ntohl_original) *ntohl; -extern decltype(recv_original) *recv; -extern decltype(connect_original) *connect; -extern decltype(send_original) *send; -extern decltype(getpeername_original) *getpeername; -extern decltype(freeaddrinfo_original) *freeaddrinfo; -extern decltype(inet_ntoa_original) *inet_ntoa; -extern decltype(inet_addr_original) *inet_addr; -extern decltype(getaddrinfo_original) *getaddrinfo; -extern decltype(sendto_original) *sendto; -extern decltype(__WSAFDIsSet_original) *__WSAFDIsSet; - -#ifdef FD_ISSET -#undef FD_ISSET -#endif - -#define FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set FAR *)(set)) diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp deleted file mode 100644 index 400796567..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImpl.hpp +++ /dev/null @@ -1,108 +0,0 @@ -#ifdef _WIN32 -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -#ifndef SFML_SOCKETIMPL_HPP -#define SFML_SOCKETIMPL_HPP - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#ifdef _WIN32_WINDOWS -#undef _WIN32_WINDOWS -#endif -#ifdef _WIN32_WINNT -#undef _WIN32_WINNT -#endif -#define _WIN32_WINDOWS 0x0501 -#define _WIN32_WINNT 0x0501 - -#include "SFML_Winsock.hpp" -#include - -namespace sf { -namespace priv { -//////////////////////////////////////////////////////////// -/// \brief Helper class implementing all the non-portable -/// socket stuff; this is the Windows version -/// -//////////////////////////////////////////////////////////// -class SocketImpl { -public: - //////////////////////////////////////////////////////////// - // Types - //////////////////////////////////////////////////////////// - typedef int AddrLength; - - //////////////////////////////////////////////////////////// - /// \brief Create an internal sockaddr_in address - /// - /// \param address Target address - /// \param port Target port - /// - /// \return sockaddr_in ready to be used by socket functions - /// - //////////////////////////////////////////////////////////// - static sockaddr_in createAddress(Uint32 address, unsigned short port); - - //////////////////////////////////////////////////////////// - /// \brief Return the value of the invalid socket - /// - /// \return Special value of the invalid socket - /// - //////////////////////////////////////////////////////////// - static SocketHandle invalidSocket(); - - //////////////////////////////////////////////////////////// - /// \brief Close and destroy a socket - /// - /// \param sock Handle of the socket to close - /// - //////////////////////////////////////////////////////////// - static void close(SocketHandle sock); - - //////////////////////////////////////////////////////////// - /// \brief Set a socket as blocking or non-blocking - /// - /// \param sock Handle of the socket - /// \param block New blocking state of the socket - /// - //////////////////////////////////////////////////////////// - static void setBlocking(SocketHandle sock, bool block); - - //////////////////////////////////////////////////////////// - /// Get the last socket error status - /// - /// \return Status corresponding to the last socket error - /// - //////////////////////////////////////////////////////////// - static Socket::Status getErrorStatus(); -}; - -} // namespace priv - -} // namespace sf - -#endif // SFML_SOCKETIMPL_HPP -#endif diff --git a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp b/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp deleted file mode 100644 index ad1026152..000000000 --- a/Source/dapi/Backend/DAPIBackendCore/SFML/Network/Win32/SocketImplWin32.cpp +++ /dev/null @@ -1,167 +0,0 @@ -#ifdef _WIN32 -//////////////////////////////////////////////////////////// -// -// SFML - Simple and Fast Multimedia Library -// Copyright (C) 2007-2018 Laurent Gomila (laurent@sfml-dev.org) -// -// This software is provided 'as-is', without any express or implied warranty. -// In no event will the authors be held liable for any damages arising from the use of this software. -// -// Permission is granted to anyone to use this software for any purpose, -// including commercial applications, and to alter it and redistribute it freely, -// subject to the following restrictions: -// -// 1. The origin of this software must not be misrepresented; -// you must not claim that you wrote the original software. -// If you use this software in a product, an acknowledgment -// in the product documentation would be appreciated but is not required. -// -// 2. Altered source versions must be plainly marked as such, -// and must not be misrepresented as being the original software. -// -// 3. This notice may not be removed or altered from any source distribution. -// -//////////////////////////////////////////////////////////// - -//////////////////////////////////////////////////////////// -// Headers -//////////////////////////////////////////////////////////// -#include -#include - -decltype(recvfrom_original) *recvfrom; -decltype(setsockopt_original) *setsockopt; -decltype(socket_original) *socket; -decltype(select_original) *select; -decltype(WSAGetLastError_original) *WSAGetLastError; -decltype(ioctlsocket_original) *ioctlsocket; -decltype(htons_original) *htons; -decltype(htonl_original) *htonl; -decltype(WSAStartup_original) *WSAStartup; -decltype(closesocket_original) *closesocket; -decltype(WSACleanup_original) *WSACleanup; -decltype(ntohs_original) *ntohs; -decltype(getsockname_original) *getsockname; -decltype(listen_original) *listen; -decltype(bind_original) *bind; -decltype(accept_original) *accept; -decltype(ntohl_original) *ntohl; -decltype(recv_original) *recv; -decltype(connect_original) *connect; -decltype(send_original) *send; -decltype(getpeername_original) *getpeername; -decltype(freeaddrinfo_original) *freeaddrinfo; -decltype(inet_ntoa_original) *inet_ntoa; -decltype(inet_addr_original) *inet_addr; -decltype(getaddrinfo_original) *getaddrinfo; -decltype(sendto_original) *sendto; -decltype(__WSAFDIsSet_original) *__WSAFDIsSet; - -namespace sf { -namespace priv { - -//////////////////////////////////////////////////////////// -// Windows needs some initialization and cleanup to get -// sockets working properly... so let's create a class that will -// do it automatically -//////////////////////////////////////////////////////////// -struct WSock32 { - WSock32() - { - ws2_32 = LoadLibrary(TEXT("ws2_32.dll")); - - (FARPROC &)recvfrom = GetProcAddress(ws2_32, "recvfrom"); - (FARPROC &)setsockopt = GetProcAddress(ws2_32, "setsockopt"); - (FARPROC &)socket = GetProcAddress(ws2_32, "socket"); - (FARPROC &)select = GetProcAddress(ws2_32, "select"); - (FARPROC &)WSAGetLastError = GetProcAddress(ws2_32, "WSAGetLastError"); - (FARPROC &)ioctlsocket = GetProcAddress(ws2_32, "ioctlsocket"); - (FARPROC &)htons = GetProcAddress(ws2_32, "htons"); - (FARPROC &)htonl = GetProcAddress(ws2_32, "htonl"); - (FARPROC &)WSAStartup = GetProcAddress(ws2_32, "WSAStartup"); - (FARPROC &)closesocket = GetProcAddress(ws2_32, "closesocket"); - (FARPROC &)WSACleanup = GetProcAddress(ws2_32, "WSACleanup"); - (FARPROC &)ntohs = GetProcAddress(ws2_32, "ntohs"); - (FARPROC &)getsockname = GetProcAddress(ws2_32, "getsockname"); - (FARPROC &)listen = GetProcAddress(ws2_32, "listen"); - (FARPROC &)bind = GetProcAddress(ws2_32, "bind"); - (FARPROC &)accept = GetProcAddress(ws2_32, "accept"); - (FARPROC &)ntohl = GetProcAddress(ws2_32, "ntohl"); - (FARPROC &)recv = GetProcAddress(ws2_32, "recv"); - (FARPROC &)connect = GetProcAddress(ws2_32, "connect"); - (FARPROC &)send = GetProcAddress(ws2_32, "send"); - (FARPROC &)getpeername = GetProcAddress(ws2_32, "getpeername"); - (FARPROC &)freeaddrinfo = GetProcAddress(ws2_32, "freeaddrinfo"); - (FARPROC &)inet_ntoa = GetProcAddress(ws2_32, "inet_ntoa"); - (FARPROC &)inet_addr = GetProcAddress(ws2_32, "inet_addr"); - (FARPROC &)getaddrinfo = GetProcAddress(ws2_32, "getaddrinfo"); - (FARPROC &)sendto = GetProcAddress(ws2_32, "sendto"); - (FARPROC &)__WSAFDIsSet = GetProcAddress(ws2_32, "__WSAFDIsSet"); - - WSADATA init; - WSAStartup(MAKEWORD(2, 2), &init); - } - - ~WSock32() - { - WSACleanup(); - - FreeLibrary(ws2_32); - } - - HMODULE ws2_32; -}; - -WSock32 wsock32; - -//////////////////////////////////////////////////////////// -sockaddr_in SocketImpl::createAddress(Uint32 address, unsigned short port) -{ - sockaddr_in addr; - std::memset(&addr, 0, sizeof(addr)); - addr.sin_addr.s_addr = htonl(address); - addr.sin_family = AF_INET; - addr.sin_port = htons(port); - - return addr; -} - -//////////////////////////////////////////////////////////// -SocketHandle SocketImpl::invalidSocket() -{ - return INVALID_SOCKET; -} - -//////////////////////////////////////////////////////////// -void SocketImpl::close(SocketHandle sock) -{ - closesocket(sock); -} - -//////////////////////////////////////////////////////////// -void SocketImpl::setBlocking(SocketHandle sock, bool block) -{ - u_long blocking = block ? 0 : 1; - ioctlsocket(sock, FIONBIO, &blocking); -} - -//////////////////////////////////////////////////////////// -Socket::Status SocketImpl::getErrorStatus() -{ - switch (WSAGetLastError()) { - case WSAEWOULDBLOCK: return Socket::NotReady; - case WSAEALREADY: return Socket::NotReady; - case WSAECONNABORTED: return Socket::Disconnected; - case WSAECONNRESET: return Socket::Disconnected; - case WSAETIMEDOUT: return Socket::Disconnected; - case WSAENETRESET: return Socket::Disconnected; - case WSAENOTCONN: return Socket::Disconnected; - case WSAEISCONN: return Socket::Done; // when connecting a non-blocking socket - default: return Socket::Error; - } -} - -} // namespace priv - -} // namespace sf -#endif diff --git a/Source/dapi/Backend/Messages/generated/command.pb.cc b/Source/dapi/Backend/Messages/generated/command.pb.cc deleted file mode 100644 index 9b8c1c07e..000000000 --- a/Source/dapi/Backend/Messages/generated/command.pb.cc +++ /dev/null @@ -1,9501 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: command.proto -// Protobuf C++ Version: 5.29.3 - -#include "command.pb.h" - -#include -#include -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/generated_message_tctable_impl.h" -#include "google/protobuf/extension_set.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/wire_format_lite.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" -PROTOBUF_PRAGMA_INIT_SEG -namespace _pb = ::google::protobuf; -namespace _pbi = ::google::protobuf::internal; -namespace _fl = ::google::protobuf::internal::field_layout; -namespace dapi { -namespace commands { - -inline constexpr UseItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR UseItem::UseItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct UseItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR UseItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~UseItemDefaultTypeInternal() {} - union { - UseItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseItemDefaultTypeInternal _UseItem_default_instance_; - -inline constexpr UseBeltItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : slot_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR UseBeltItem::UseBeltItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct UseBeltItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR UseBeltItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~UseBeltItemDefaultTypeInternal() {} - union { - UseBeltItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 UseBeltItemDefaultTypeInternal _UseBeltItem_default_instance_; - -inline constexpr ToggleMenu::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ToggleMenu::ToggleMenu(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ToggleMenuDefaultTypeInternal { - PROTOBUF_CONSTEXPR ToggleMenuDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ToggleMenuDefaultTypeInternal() {} - union { - ToggleMenu _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleMenuDefaultTypeInternal _ToggleMenu_default_instance_; - -inline constexpr ToggleInventory::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ToggleInventory::ToggleInventory(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ToggleInventoryDefaultTypeInternal { - PROTOBUF_CONSTEXPR ToggleInventoryDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ToggleInventoryDefaultTypeInternal() {} - union { - ToggleInventory _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleInventoryDefaultTypeInternal _ToggleInventory_default_instance_; - -inline constexpr ToggleCharacterSheet::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ToggleCharacterSheet::ToggleCharacterSheet(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ToggleCharacterSheetDefaultTypeInternal { - PROTOBUF_CONSTEXPR ToggleCharacterSheetDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ToggleCharacterSheetDefaultTypeInternal() {} - union { - ToggleCharacterSheet _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ToggleCharacterSheetDefaultTypeInternal _ToggleCharacterSheet_default_instance_; - -inline constexpr Talk::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : targetx_{0u}, - targety_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR Talk::Talk(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct TalkDefaultTypeInternal { - PROTOBUF_CONSTEXPR TalkDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~TalkDefaultTypeInternal() {} - union { - Talk _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TalkDefaultTypeInternal _Talk_default_instance_; - -inline constexpr SkillRepair::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SkillRepair::SkillRepair(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SkillRepairDefaultTypeInternal { - PROTOBUF_CONSTEXPR SkillRepairDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SkillRepairDefaultTypeInternal() {} - union { - SkillRepair _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillRepairDefaultTypeInternal _SkillRepair_default_instance_; - -inline constexpr SkillRecharge::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SkillRecharge::SkillRecharge(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SkillRechargeDefaultTypeInternal { - PROTOBUF_CONSTEXPR SkillRechargeDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SkillRechargeDefaultTypeInternal() {} - union { - SkillRecharge _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SkillRechargeDefaultTypeInternal _SkillRecharge_default_instance_; - -inline constexpr SetSpell::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : spellid_{0}, - spelltype_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SetSpell::SetSpell(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SetSpellDefaultTypeInternal { - PROTOBUF_CONSTEXPR SetSpellDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SetSpellDefaultTypeInternal() {} - union { - SetSpell _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetSpellDefaultTypeInternal _SetSpell_default_instance_; - -inline constexpr SetFPS::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : fps_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SetFPS::SetFPS(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SetFPSDefaultTypeInternal { - PROTOBUF_CONSTEXPR SetFPSDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SetFPSDefaultTypeInternal() {} - union { - SetFPS _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SetFPSDefaultTypeInternal _SetFPS_default_instance_; - -inline constexpr SellItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SellItem::SellItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SellItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR SellItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SellItemDefaultTypeInternal() {} - union { - SellItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SellItemDefaultTypeInternal _SellItem_default_instance_; - -inline constexpr SelectStoreOption::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : option_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SelectStoreOption::SelectStoreOption(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SelectStoreOptionDefaultTypeInternal { - PROTOBUF_CONSTEXPR SelectStoreOptionDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SelectStoreOptionDefaultTypeInternal() {} - union { - SelectStoreOption _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SelectStoreOptionDefaultTypeInternal _SelectStoreOption_default_instance_; - -inline constexpr SaveGame::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR SaveGame::SaveGame(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct SaveGameDefaultTypeInternal { - PROTOBUF_CONSTEXPR SaveGameDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~SaveGameDefaultTypeInternal() {} - union { - SaveGame _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 SaveGameDefaultTypeInternal _SaveGame_default_instance_; - -inline constexpr RepairItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR RepairItem::RepairItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct RepairItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR RepairItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~RepairItemDefaultTypeInternal() {} - union { - RepairItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RepairItemDefaultTypeInternal _RepairItem_default_instance_; - -inline constexpr RechargeItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR RechargeItem::RechargeItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct RechargeItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR RechargeItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~RechargeItemDefaultTypeInternal() {} - union { - RechargeItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 RechargeItemDefaultTypeInternal _RechargeItem_default_instance_; - -inline constexpr Quit::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR Quit::Quit(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct QuitDefaultTypeInternal { - PROTOBUF_CONSTEXPR QuitDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~QuitDefaultTypeInternal() {} - union { - Quit _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QuitDefaultTypeInternal _Quit_default_instance_; - -inline constexpr PutInCursor::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR PutInCursor::PutInCursor(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct PutInCursorDefaultTypeInternal { - PROTOBUF_CONSTEXPR PutInCursorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~PutInCursorDefaultTypeInternal() {} - union { - PutInCursor _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutInCursorDefaultTypeInternal _PutInCursor_default_instance_; - -inline constexpr PutCursorItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : target_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR PutCursorItem::PutCursorItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct PutCursorItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR PutCursorItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~PutCursorItemDefaultTypeInternal() {} - union { - PutCursorItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PutCursorItemDefaultTypeInternal _PutCursorItem_default_instance_; - -inline constexpr OperateObject::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : index_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR OperateObject::OperateObject(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct OperateObjectDefaultTypeInternal { - PROTOBUF_CONSTEXPR OperateObjectDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~OperateObjectDefaultTypeInternal() {} - union { - OperateObject _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 OperateObjectDefaultTypeInternal _OperateObject_default_instance_; - -inline constexpr Move::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : type_{0u}, - targetx_{0u}, - targety_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR Move::Move(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct MoveDefaultTypeInternal { - PROTOBUF_CONSTEXPR MoveDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~MoveDefaultTypeInternal() {} - union { - Move _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MoveDefaultTypeInternal _Move_default_instance_; - -inline constexpr IncreaseStat::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : stat_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR IncreaseStat::IncreaseStat(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct IncreaseStatDefaultTypeInternal { - PROTOBUF_CONSTEXPR IncreaseStatDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~IncreaseStatDefaultTypeInternal() {} - union { - IncreaseStat _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IncreaseStatDefaultTypeInternal _IncreaseStat_default_instance_; - -inline constexpr IdentifyStoreItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR IdentifyStoreItem::IdentifyStoreItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct IdentifyStoreItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR IdentifyStoreItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~IdentifyStoreItemDefaultTypeInternal() {} - union { - IdentifyStoreItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentifyStoreItemDefaultTypeInternal _IdentifyStoreItem_default_instance_; - -inline constexpr IdentifyItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR IdentifyItem::IdentifyItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct IdentifyItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR IdentifyItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~IdentifyItemDefaultTypeInternal() {} - union { - IdentifyItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 IdentifyItemDefaultTypeInternal _IdentifyItem_default_instance_; - -inline constexpr GetItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR GetItem::GetItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct GetItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR GetItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~GetItemDefaultTypeInternal() {} - union { - GetItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 GetItemDefaultTypeInternal _GetItem_default_instance_; - -inline constexpr DropCursorItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR DropCursorItem::DropCursorItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct DropCursorItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR DropCursorItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~DropCursorItemDefaultTypeInternal() {} - union { - DropCursorItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DropCursorItemDefaultTypeInternal _DropCursorItem_default_instance_; - -inline constexpr DisarmTrap::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : index_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR DisarmTrap::DisarmTrap(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct DisarmTrapDefaultTypeInternal { - PROTOBUF_CONSTEXPR DisarmTrapDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~DisarmTrapDefaultTypeInternal() {} - union { - DisarmTrap _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 DisarmTrapDefaultTypeInternal _DisarmTrap_default_instance_; - -inline constexpr ClearCursor::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ClearCursor::ClearCursor(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ClearCursorDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClearCursorDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ClearCursorDefaultTypeInternal() {} - union { - ClearCursor _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClearCursorDefaultTypeInternal _ClearCursor_default_instance_; - -inline constexpr CastXY::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : x_{0}, - y_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR CastXY::CastXY(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct CastXYDefaultTypeInternal { - PROTOBUF_CONSTEXPR CastXYDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~CastXYDefaultTypeInternal() {} - union { - CastXY _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CastXYDefaultTypeInternal _CastXY_default_instance_; - -inline constexpr CastMonster::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : index_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR CastMonster::CastMonster(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct CastMonsterDefaultTypeInternal { - PROTOBUF_CONSTEXPR CastMonsterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~CastMonsterDefaultTypeInternal() {} - union { - CastMonster _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CastMonsterDefaultTypeInternal _CastMonster_default_instance_; - -inline constexpr CancelQText::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR CancelQText::CancelQText(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct CancelQTextDefaultTypeInternal { - PROTOBUF_CONSTEXPR CancelQTextDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~CancelQTextDefaultTypeInternal() {} - union { - CancelQText _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CancelQTextDefaultTypeInternal _CancelQText_default_instance_; - -inline constexpr BuyItem::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR BuyItem::BuyItem(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct BuyItemDefaultTypeInternal { - PROTOBUF_CONSTEXPR BuyItemDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~BuyItemDefaultTypeInternal() {} - union { - BuyItem _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 BuyItemDefaultTypeInternal _BuyItem_default_instance_; - -inline constexpr AttackXY::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : x_{0}, - y_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR AttackXY::AttackXY(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct AttackXYDefaultTypeInternal { - PROTOBUF_CONSTEXPR AttackXYDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~AttackXYDefaultTypeInternal() {} - union { - AttackXY _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackXYDefaultTypeInternal _AttackXY_default_instance_; - -inline constexpr AttackMonster::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : index_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR AttackMonster::AttackMonster(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct AttackMonsterDefaultTypeInternal { - PROTOBUF_CONSTEXPR AttackMonsterDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~AttackMonsterDefaultTypeInternal() {} - union { - AttackMonster _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 AttackMonsterDefaultTypeInternal _AttackMonster_default_instance_; - -inline constexpr Command::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : command_{}, - _cached_size_{0}, - _oneof_case_{} {} - -template -PROTOBUF_CONSTEXPR Command::Command(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct CommandDefaultTypeInternal { - PROTOBUF_CONSTEXPR CommandDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~CommandDefaultTypeInternal() {} - union { - Command _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 CommandDefaultTypeInternal _Command_default_instance_; -} // namespace commands -} // namespace dapi -namespace dapi { -namespace commands { -// =================================================================== - -class SetFPS::_Internal { - public: -}; - -SetFPS::SetFPS(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SetFPS) -} -SetFPS::SetFPS( - ::google::protobuf::Arena* arena, const SetFPS& from) - : SetFPS(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SetFPS::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SetFPS::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.fps_ = {}; -} -SetFPS::~SetFPS() { - // @@protoc_insertion_point(destructor:dapi.commands.SetFPS) - SharedDtor(*this); -} -inline void SetFPS::SharedDtor(MessageLite& self) { - SetFPS& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SetFPS::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SetFPS(arena); -} -constexpr auto SetFPS::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetFPS), - alignof(SetFPS)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> SetFPS::_class_data_ = { - { - &_SetFPS_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SetFPS::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SetFPS::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SetFPS::ByteSizeLong, - &SetFPS::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetFPS, _impl_._cached_size_), - true, - }, - "dapi.commands.SetFPS", -}; -const ::google::protobuf::internal::ClassData* SetFPS::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SetFPS::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SetFPS>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 FPS = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetFPS, _impl_.fps_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 FPS = 1; - {PROTOBUF_FIELD_OFFSET(SetFPS, _impl_.fps_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SetFPS::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SetFPS) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.fps_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SetFPS::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SetFPS& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SetFPS::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SetFPS& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SetFPS) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 FPS = 1; - if (this_._internal_fps() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_fps(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SetFPS) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SetFPS::ByteSizeLong(const MessageLite& base) { - const SetFPS& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SetFPS::ByteSizeLong() const { - const SetFPS& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SetFPS) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 FPS = 1; - if (this_._internal_fps() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_fps()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SetFPS::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SetFPS) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_fps() != 0) { - _this->_impl_.fps_ = from._impl_.fps_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SetFPS::CopyFrom(const SetFPS& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SetFPS) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SetFPS::InternalSwap(SetFPS* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.fps_, other->_impl_.fps_); -} - -// =================================================================== - -class CancelQText::_Internal { - public: -}; - -CancelQText::CancelQText(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.CancelQText) -} -CancelQText::CancelQText( - ::google::protobuf::Arena* arena, const CancelQText& from) - : CancelQText(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE CancelQText::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void CancelQText::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -CancelQText::~CancelQText() { - // @@protoc_insertion_point(destructor:dapi.commands.CancelQText) - SharedDtor(*this); -} -inline void CancelQText::SharedDtor(MessageLite& self) { - CancelQText& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* CancelQText::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) CancelQText(arena); -} -constexpr auto CancelQText::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CancelQText), - alignof(CancelQText)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> CancelQText::_class_data_ = { - { - &_CancelQText_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &CancelQText::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &CancelQText::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &CancelQText::ByteSizeLong, - &CancelQText::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(CancelQText, _impl_._cached_size_), - true, - }, - "dapi.commands.CancelQText", -}; -const ::google::protobuf::internal::ClassData* CancelQText::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> CancelQText::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::CancelQText>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void CancelQText::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.CancelQText) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* CancelQText::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const CancelQText& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* CancelQText::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const CancelQText& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CancelQText) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CancelQText) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t CancelQText::ByteSizeLong(const MessageLite& base) { - const CancelQText& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t CancelQText::ByteSizeLong() const { - const CancelQText& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CancelQText) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void CancelQText::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CancelQText) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void CancelQText::CopyFrom(const CancelQText& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CancelQText) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void CancelQText::InternalSwap(CancelQText* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class Move::_Internal { - public: -}; - -Move::Move(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.Move) -} -Move::Move( - ::google::protobuf::Arena* arena, const Move& from) - : Move(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE Move::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void Move::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, type_), - 0, - offsetof(Impl_, targety_) - - offsetof(Impl_, type_) + - sizeof(Impl_::targety_)); -} -Move::~Move() { - // @@protoc_insertion_point(destructor:dapi.commands.Move) - SharedDtor(*this); -} -inline void Move::SharedDtor(MessageLite& self) { - Move& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* Move::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) Move(arena); -} -constexpr auto Move::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Move), - alignof(Move)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<19> Move::_class_data_ = { - { - &_Move_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &Move::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &Move::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &Move::ByteSizeLong, - &Move::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(Move, _impl_._cached_size_), - true, - }, - "dapi.commands.Move", -}; -const ::google::protobuf::internal::ClassData* Move::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 0, 0, 2> Move::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap - offsetof(decltype(_table_), field_entries), - 3, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::Move>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 type = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.type_)}}, - // uint32 targetX = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.targetx_)}}, - // uint32 targetY = 3; - {::_pbi::TcParser::FastV32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 type = 1; - {PROTOBUF_FIELD_OFFSET(Move, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 targetX = 2; - {PROTOBUF_FIELD_OFFSET(Move, _impl_.targetx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 targetY = 3; - {PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void Move::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.Move) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.type_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.targety_) - - reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.targety_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* Move::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const Move& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* Move::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const Move& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Move) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 type = 1; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_type(), target); - } - - // uint32 targetX = 2; - if (this_._internal_targetx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_targetx(), target); - } - - // uint32 targetY = 3; - if (this_._internal_targety() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 3, this_._internal_targety(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Move) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t Move::ByteSizeLong(const MessageLite& base) { - const Move& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t Move::ByteSizeLong() const { - const Move& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Move) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 type = 1; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_type()); - } - // uint32 targetX = 2; - if (this_._internal_targetx() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_targetx()); - } - // uint32 targetY = 3; - if (this_._internal_targety() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_targety()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void Move::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Move) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - if (from._internal_targetx() != 0) { - _this->_impl_.targetx_ = from._impl_.targetx_; - } - if (from._internal_targety() != 0) { - _this->_impl_.targety_ = from._impl_.targety_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void Move::CopyFrom(const Move& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Move) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void Move::InternalSwap(Move* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(Move, _impl_.targety_) - + sizeof(Move::_impl_.targety_) - - PROTOBUF_FIELD_OFFSET(Move, _impl_.type_)>( - reinterpret_cast(&_impl_.type_), - reinterpret_cast(&other->_impl_.type_)); -} - -// =================================================================== - -class Talk::_Internal { - public: -}; - -Talk::Talk(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.Talk) -} -Talk::Talk( - ::google::protobuf::Arena* arena, const Talk& from) - : Talk(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE Talk::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void Talk::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, targetx_), - 0, - offsetof(Impl_, targety_) - - offsetof(Impl_, targetx_) + - sizeof(Impl_::targety_)); -} -Talk::~Talk() { - // @@protoc_insertion_point(destructor:dapi.commands.Talk) - SharedDtor(*this); -} -inline void Talk::SharedDtor(MessageLite& self) { - Talk& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* Talk::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) Talk(arena); -} -constexpr auto Talk::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Talk), - alignof(Talk)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<19> Talk::_class_data_ = { - { - &_Talk_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &Talk::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &Talk::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &Talk::ByteSizeLong, - &Talk::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(Talk, _impl_._cached_size_), - true, - }, - "dapi.commands.Talk", -}; -const ::google::protobuf::internal::ClassData* Talk::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 0, 2> Talk::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::Talk>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 targetY = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_)}}, - // uint32 targetX = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 targetX = 1; - {PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 targetY = 2; - {PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void Talk::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.Talk) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.targetx_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.targety_) - - reinterpret_cast(&_impl_.targetx_)) + sizeof(_impl_.targety_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* Talk::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const Talk& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* Talk::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const Talk& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Talk) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 targetX = 1; - if (this_._internal_targetx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_targetx(), target); - } - - // uint32 targetY = 2; - if (this_._internal_targety() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_targety(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Talk) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t Talk::ByteSizeLong(const MessageLite& base) { - const Talk& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t Talk::ByteSizeLong() const { - const Talk& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Talk) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 targetX = 1; - if (this_._internal_targetx() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_targetx()); - } - // uint32 targetY = 2; - if (this_._internal_targety() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_targety()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void Talk::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Talk) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_targetx() != 0) { - _this->_impl_.targetx_ = from._impl_.targetx_; - } - if (from._internal_targety() != 0) { - _this->_impl_.targety_ = from._impl_.targety_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void Talk::CopyFrom(const Talk& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Talk) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void Talk::InternalSwap(Talk* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(Talk, _impl_.targety_) - + sizeof(Talk::_impl_.targety_) - - PROTOBUF_FIELD_OFFSET(Talk, _impl_.targetx_)>( - reinterpret_cast(&_impl_.targetx_), - reinterpret_cast(&other->_impl_.targetx_)); -} - -// =================================================================== - -class SelectStoreOption::_Internal { - public: -}; - -SelectStoreOption::SelectStoreOption(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SelectStoreOption) -} -SelectStoreOption::SelectStoreOption( - ::google::protobuf::Arena* arena, const SelectStoreOption& from) - : SelectStoreOption(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SelectStoreOption::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SelectStoreOption::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.option_ = {}; -} -SelectStoreOption::~SelectStoreOption() { - // @@protoc_insertion_point(destructor:dapi.commands.SelectStoreOption) - SharedDtor(*this); -} -inline void SelectStoreOption::SharedDtor(MessageLite& self) { - SelectStoreOption& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SelectStoreOption::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SelectStoreOption(arena); -} -constexpr auto SelectStoreOption::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SelectStoreOption), - alignof(SelectStoreOption)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<32> SelectStoreOption::_class_data_ = { - { - &_SelectStoreOption_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SelectStoreOption::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SelectStoreOption::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SelectStoreOption::ByteSizeLong, - &SelectStoreOption::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_._cached_size_), - true, - }, - "dapi.commands.SelectStoreOption", -}; -const ::google::protobuf::internal::ClassData* SelectStoreOption::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SelectStoreOption::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SelectStoreOption>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 option = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_.option_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 option = 1; - {PROTOBUF_FIELD_OFFSET(SelectStoreOption, _impl_.option_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SelectStoreOption::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SelectStoreOption) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.option_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SelectStoreOption::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SelectStoreOption& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SelectStoreOption::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SelectStoreOption& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SelectStoreOption) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 option = 1; - if (this_._internal_option() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_option(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SelectStoreOption) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SelectStoreOption::ByteSizeLong(const MessageLite& base) { - const SelectStoreOption& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SelectStoreOption::ByteSizeLong() const { - const SelectStoreOption& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SelectStoreOption) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 option = 1; - if (this_._internal_option() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_option()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SelectStoreOption::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SelectStoreOption) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_option() != 0) { - _this->_impl_.option_ = from._impl_.option_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SelectStoreOption::CopyFrom(const SelectStoreOption& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SelectStoreOption) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SelectStoreOption::InternalSwap(SelectStoreOption* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.option_, other->_impl_.option_); -} - -// =================================================================== - -class BuyItem::_Internal { - public: -}; - -BuyItem::BuyItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.BuyItem) -} -BuyItem::BuyItem( - ::google::protobuf::Arena* arena, const BuyItem& from) - : BuyItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE BuyItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void BuyItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -BuyItem::~BuyItem() { - // @@protoc_insertion_point(destructor:dapi.commands.BuyItem) - SharedDtor(*this); -} -inline void BuyItem::SharedDtor(MessageLite& self) { - BuyItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* BuyItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) BuyItem(arena); -} -constexpr auto BuyItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(BuyItem), - alignof(BuyItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> BuyItem::_class_data_ = { - { - &_BuyItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &BuyItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &BuyItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &BuyItem::ByteSizeLong, - &BuyItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(BuyItem, _impl_._cached_size_), - true, - }, - "dapi.commands.BuyItem", -}; -const ::google::protobuf::internal::ClassData* BuyItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> BuyItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::BuyItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(BuyItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(BuyItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void BuyItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.BuyItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* BuyItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const BuyItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* BuyItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const BuyItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.BuyItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.BuyItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t BuyItem::ByteSizeLong(const MessageLite& base) { - const BuyItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t BuyItem::ByteSizeLong() const { - const BuyItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.BuyItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void BuyItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.BuyItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void BuyItem::CopyFrom(const BuyItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.BuyItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void BuyItem::InternalSwap(BuyItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class SellItem::_Internal { - public: -}; - -SellItem::SellItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SellItem) -} -SellItem::SellItem( - ::google::protobuf::Arena* arena, const SellItem& from) - : SellItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SellItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SellItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -SellItem::~SellItem() { - // @@protoc_insertion_point(destructor:dapi.commands.SellItem) - SharedDtor(*this); -} -inline void SellItem::SharedDtor(MessageLite& self) { - SellItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SellItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SellItem(arena); -} -constexpr auto SellItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SellItem), - alignof(SellItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<23> SellItem::_class_data_ = { - { - &_SellItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SellItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SellItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SellItem::ByteSizeLong, - &SellItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SellItem, _impl_._cached_size_), - true, - }, - "dapi.commands.SellItem", -}; -const ::google::protobuf::internal::ClassData* SellItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SellItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SellItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SellItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(SellItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SellItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SellItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SellItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SellItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SellItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SellItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SellItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SellItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SellItem::ByteSizeLong(const MessageLite& base) { - const SellItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SellItem::ByteSizeLong() const { - const SellItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SellItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SellItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SellItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SellItem::CopyFrom(const SellItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SellItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SellItem::InternalSwap(SellItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class RechargeItem::_Internal { - public: -}; - -RechargeItem::RechargeItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.RechargeItem) -} -RechargeItem::RechargeItem( - ::google::protobuf::Arena* arena, const RechargeItem& from) - : RechargeItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE RechargeItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void RechargeItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -RechargeItem::~RechargeItem() { - // @@protoc_insertion_point(destructor:dapi.commands.RechargeItem) - SharedDtor(*this); -} -inline void RechargeItem::SharedDtor(MessageLite& self) { - RechargeItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* RechargeItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) RechargeItem(arena); -} -constexpr auto RechargeItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RechargeItem), - alignof(RechargeItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<27> RechargeItem::_class_data_ = { - { - &_RechargeItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &RechargeItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &RechargeItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &RechargeItem::ByteSizeLong, - &RechargeItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_._cached_size_), - true, - }, - "dapi.commands.RechargeItem", -}; -const ::google::protobuf::internal::ClassData* RechargeItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RechargeItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::RechargeItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(RechargeItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void RechargeItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.RechargeItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* RechargeItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const RechargeItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* RechargeItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const RechargeItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.RechargeItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.RechargeItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t RechargeItem::ByteSizeLong(const MessageLite& base) { - const RechargeItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t RechargeItem::ByteSizeLong() const { - const RechargeItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.RechargeItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void RechargeItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.RechargeItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void RechargeItem::CopyFrom(const RechargeItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.RechargeItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void RechargeItem::InternalSwap(RechargeItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class RepairItem::_Internal { - public: -}; - -RepairItem::RepairItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.RepairItem) -} -RepairItem::RepairItem( - ::google::protobuf::Arena* arena, const RepairItem& from) - : RepairItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE RepairItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void RepairItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -RepairItem::~RepairItem() { - // @@protoc_insertion_point(destructor:dapi.commands.RepairItem) - SharedDtor(*this); -} -inline void RepairItem::SharedDtor(MessageLite& self) { - RepairItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* RepairItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) RepairItem(arena); -} -constexpr auto RepairItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(RepairItem), - alignof(RepairItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<25> RepairItem::_class_data_ = { - { - &_RepairItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &RepairItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &RepairItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &RepairItem::ByteSizeLong, - &RepairItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(RepairItem, _impl_._cached_size_), - true, - }, - "dapi.commands.RepairItem", -}; -const ::google::protobuf::internal::ClassData* RepairItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> RepairItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::RepairItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(RepairItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(RepairItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void RepairItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.RepairItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* RepairItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const RepairItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* RepairItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const RepairItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.RepairItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.RepairItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t RepairItem::ByteSizeLong(const MessageLite& base) { - const RepairItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t RepairItem::ByteSizeLong() const { - const RepairItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.RepairItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void RepairItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.RepairItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void RepairItem::CopyFrom(const RepairItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.RepairItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void RepairItem::InternalSwap(RepairItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class AttackMonster::_Internal { - public: -}; - -AttackMonster::AttackMonster(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.AttackMonster) -} -AttackMonster::AttackMonster( - ::google::protobuf::Arena* arena, const AttackMonster& from) - : AttackMonster(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE AttackMonster::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void AttackMonster::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.index_ = {}; -} -AttackMonster::~AttackMonster() { - // @@protoc_insertion_point(destructor:dapi.commands.AttackMonster) - SharedDtor(*this); -} -inline void AttackMonster::SharedDtor(MessageLite& self) { - AttackMonster& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* AttackMonster::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) AttackMonster(arena); -} -constexpr auto AttackMonster::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AttackMonster), - alignof(AttackMonster)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<28> AttackMonster::_class_data_ = { - { - &_AttackMonster_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &AttackMonster::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &AttackMonster::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &AttackMonster::ByteSizeLong, - &AttackMonster::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_._cached_size_), - true, - }, - "dapi.commands.AttackMonster", -}; -const ::google::protobuf::internal::ClassData* AttackMonster::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> AttackMonster::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::AttackMonster>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 index = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_.index_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 index = 1; - {PROTOBUF_FIELD_OFFSET(AttackMonster, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void AttackMonster::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.AttackMonster) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* AttackMonster::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const AttackMonster& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* AttackMonster::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const AttackMonster& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.AttackMonster) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 index = 1; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.AttackMonster) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t AttackMonster::ByteSizeLong(const MessageLite& base) { - const AttackMonster& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t AttackMonster::ByteSizeLong() const { - const AttackMonster& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.AttackMonster) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 index = 1; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void AttackMonster::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.AttackMonster) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void AttackMonster::CopyFrom(const AttackMonster& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.AttackMonster) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void AttackMonster::InternalSwap(AttackMonster* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.index_, other->_impl_.index_); -} - -// =================================================================== - -class AttackXY::_Internal { - public: -}; - -AttackXY::AttackXY(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.AttackXY) -} -AttackXY::AttackXY( - ::google::protobuf::Arena* arena, const AttackXY& from) - : AttackXY(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE AttackXY::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void AttackXY::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, x_), - 0, - offsetof(Impl_, y_) - - offsetof(Impl_, x_) + - sizeof(Impl_::y_)); -} -AttackXY::~AttackXY() { - // @@protoc_insertion_point(destructor:dapi.commands.AttackXY) - SharedDtor(*this); -} -inline void AttackXY::SharedDtor(MessageLite& self) { - AttackXY& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* AttackXY::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) AttackXY(arena); -} -constexpr auto AttackXY::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(AttackXY), - alignof(AttackXY)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<23> AttackXY::_class_data_ = { - { - &_AttackXY_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &AttackXY::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &AttackXY::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &AttackXY::ByteSizeLong, - &AttackXY::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(AttackXY, _impl_._cached_size_), - true, - }, - "dapi.commands.AttackXY", -}; -const ::google::protobuf::internal::ClassData* AttackXY::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 0, 2> AttackXY::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::AttackXY>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // sint32 y = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_)}}, - // sint32 x = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 x = 1; - {PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 y = 2; - {PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void AttackXY::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.AttackXY) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.x_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.y_) - - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.y_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* AttackXY::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const AttackXY& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* AttackXY::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const AttackXY& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.AttackXY) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 x = 1; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_x(), target); - } - - // sint32 y = 2; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_y(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.AttackXY) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t AttackXY::ByteSizeLong(const MessageLite& base) { - const AttackXY& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t AttackXY::ByteSizeLong() const { - const AttackXY& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.AttackXY) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // sint32 x = 1; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_x()); - } - // sint32 y = 2; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_y()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void AttackXY::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.AttackXY) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void AttackXY::CopyFrom(const AttackXY& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.AttackXY) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void AttackXY::InternalSwap(AttackXY* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.y_) - + sizeof(AttackXY::_impl_.y_) - - PROTOBUF_FIELD_OFFSET(AttackXY, _impl_.x_)>( - reinterpret_cast(&_impl_.x_), - reinterpret_cast(&other->_impl_.x_)); -} - -// =================================================================== - -class OperateObject::_Internal { - public: -}; - -OperateObject::OperateObject(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.OperateObject) -} -OperateObject::OperateObject( - ::google::protobuf::Arena* arena, const OperateObject& from) - : OperateObject(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE OperateObject::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void OperateObject::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.index_ = {}; -} -OperateObject::~OperateObject() { - // @@protoc_insertion_point(destructor:dapi.commands.OperateObject) - SharedDtor(*this); -} -inline void OperateObject::SharedDtor(MessageLite& self) { - OperateObject& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* OperateObject::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) OperateObject(arena); -} -constexpr auto OperateObject::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(OperateObject), - alignof(OperateObject)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<28> OperateObject::_class_data_ = { - { - &_OperateObject_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &OperateObject::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &OperateObject::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &OperateObject::ByteSizeLong, - &OperateObject::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(OperateObject, _impl_._cached_size_), - true, - }, - "dapi.commands.OperateObject", -}; -const ::google::protobuf::internal::ClassData* OperateObject::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> OperateObject::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::OperateObject>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 index = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(OperateObject, _impl_.index_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 index = 1; - {PROTOBUF_FIELD_OFFSET(OperateObject, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void OperateObject::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.OperateObject) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* OperateObject::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const OperateObject& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* OperateObject::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const OperateObject& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.OperateObject) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 index = 1; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.OperateObject) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t OperateObject::ByteSizeLong(const MessageLite& base) { - const OperateObject& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t OperateObject::ByteSizeLong() const { - const OperateObject& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.OperateObject) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 index = 1; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void OperateObject::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.OperateObject) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void OperateObject::CopyFrom(const OperateObject& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.OperateObject) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void OperateObject::InternalSwap(OperateObject* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.index_, other->_impl_.index_); -} - -// =================================================================== - -class UseBeltItem::_Internal { - public: -}; - -UseBeltItem::UseBeltItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.UseBeltItem) -} -UseBeltItem::UseBeltItem( - ::google::protobuf::Arena* arena, const UseBeltItem& from) - : UseBeltItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE UseBeltItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void UseBeltItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.slot_ = {}; -} -UseBeltItem::~UseBeltItem() { - // @@protoc_insertion_point(destructor:dapi.commands.UseBeltItem) - SharedDtor(*this); -} -inline void UseBeltItem::SharedDtor(MessageLite& self) { - UseBeltItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* UseBeltItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) UseBeltItem(arena); -} -constexpr auto UseBeltItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseBeltItem), - alignof(UseBeltItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> UseBeltItem::_class_data_ = { - { - &_UseBeltItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &UseBeltItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &UseBeltItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &UseBeltItem::ByteSizeLong, - &UseBeltItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_._cached_size_), - true, - }, - "dapi.commands.UseBeltItem", -}; -const ::google::protobuf::internal::ClassData* UseBeltItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> UseBeltItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::UseBeltItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 slot = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_.slot_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 slot = 1; - {PROTOBUF_FIELD_OFFSET(UseBeltItem, _impl_.slot_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void UseBeltItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.UseBeltItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.slot_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* UseBeltItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const UseBeltItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* UseBeltItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const UseBeltItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.UseBeltItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 slot = 1; - if (this_._internal_slot() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_slot(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.UseBeltItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t UseBeltItem::ByteSizeLong(const MessageLite& base) { - const UseBeltItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t UseBeltItem::ByteSizeLong() const { - const UseBeltItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.UseBeltItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 slot = 1; - if (this_._internal_slot() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_slot()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void UseBeltItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.UseBeltItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_slot() != 0) { - _this->_impl_.slot_ = from._impl_.slot_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void UseBeltItem::CopyFrom(const UseBeltItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.UseBeltItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void UseBeltItem::InternalSwap(UseBeltItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.slot_, other->_impl_.slot_); -} - -// =================================================================== - -class ToggleCharacterSheet::_Internal { - public: -}; - -ToggleCharacterSheet::ToggleCharacterSheet(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleCharacterSheet) -} -ToggleCharacterSheet::ToggleCharacterSheet( - ::google::protobuf::Arena* arena, const ToggleCharacterSheet& from) - : ToggleCharacterSheet(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ToggleCharacterSheet::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ToggleCharacterSheet::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -ToggleCharacterSheet::~ToggleCharacterSheet() { - // @@protoc_insertion_point(destructor:dapi.commands.ToggleCharacterSheet) - SharedDtor(*this); -} -inline void ToggleCharacterSheet::SharedDtor(MessageLite& self) { - ToggleCharacterSheet& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ToggleCharacterSheet::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ToggleCharacterSheet(arena); -} -constexpr auto ToggleCharacterSheet::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleCharacterSheet), - alignof(ToggleCharacterSheet)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<35> ToggleCharacterSheet::_class_data_ = { - { - &_ToggleCharacterSheet_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ToggleCharacterSheet::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ToggleCharacterSheet::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ToggleCharacterSheet::ByteSizeLong, - &ToggleCharacterSheet::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ToggleCharacterSheet, _impl_._cached_size_), - true, - }, - "dapi.commands.ToggleCharacterSheet", -}; -const ::google::protobuf::internal::ClassData* ToggleCharacterSheet::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleCharacterSheet::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::ToggleCharacterSheet>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ToggleCharacterSheet::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleCharacterSheet) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ToggleCharacterSheet::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ToggleCharacterSheet& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ToggleCharacterSheet::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ToggleCharacterSheet& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleCharacterSheet) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleCharacterSheet) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ToggleCharacterSheet::ByteSizeLong(const MessageLite& base) { - const ToggleCharacterSheet& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ToggleCharacterSheet::ByteSizeLong() const { - const ToggleCharacterSheet& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleCharacterSheet) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ToggleCharacterSheet::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleCharacterSheet) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ToggleCharacterSheet::CopyFrom(const ToggleCharacterSheet& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleCharacterSheet) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ToggleCharacterSheet::InternalSwap(ToggleCharacterSheet* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class IncreaseStat::_Internal { - public: -}; - -IncreaseStat::IncreaseStat(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.IncreaseStat) -} -IncreaseStat::IncreaseStat( - ::google::protobuf::Arena* arena, const IncreaseStat& from) - : IncreaseStat(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE IncreaseStat::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void IncreaseStat::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.stat_ = {}; -} -IncreaseStat::~IncreaseStat() { - // @@protoc_insertion_point(destructor:dapi.commands.IncreaseStat) - SharedDtor(*this); -} -inline void IncreaseStat::SharedDtor(MessageLite& self) { - IncreaseStat& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* IncreaseStat::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) IncreaseStat(arena); -} -constexpr auto IncreaseStat::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IncreaseStat), - alignof(IncreaseStat)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<27> IncreaseStat::_class_data_ = { - { - &_IncreaseStat_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &IncreaseStat::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &IncreaseStat::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &IncreaseStat::ByteSizeLong, - &IncreaseStat::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_._cached_size_), - true, - }, - "dapi.commands.IncreaseStat", -}; -const ::google::protobuf::internal::ClassData* IncreaseStat::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IncreaseStat::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::IncreaseStat>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 stat = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_.stat_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 stat = 1; - {PROTOBUF_FIELD_OFFSET(IncreaseStat, _impl_.stat_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void IncreaseStat::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.IncreaseStat) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.stat_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* IncreaseStat::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const IncreaseStat& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* IncreaseStat::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const IncreaseStat& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IncreaseStat) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 stat = 1; - if (this_._internal_stat() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_stat(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IncreaseStat) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t IncreaseStat::ByteSizeLong(const MessageLite& base) { - const IncreaseStat& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t IncreaseStat::ByteSizeLong() const { - const IncreaseStat& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IncreaseStat) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 stat = 1; - if (this_._internal_stat() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_stat()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void IncreaseStat::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IncreaseStat) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_stat() != 0) { - _this->_impl_.stat_ = from._impl_.stat_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void IncreaseStat::CopyFrom(const IncreaseStat& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IncreaseStat) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void IncreaseStat::InternalSwap(IncreaseStat* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.stat_, other->_impl_.stat_); -} - -// =================================================================== - -class GetItem::_Internal { - public: -}; - -GetItem::GetItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.GetItem) -} -GetItem::GetItem( - ::google::protobuf::Arena* arena, const GetItem& from) - : GetItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE GetItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void GetItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -GetItem::~GetItem() { - // @@protoc_insertion_point(destructor:dapi.commands.GetItem) - SharedDtor(*this); -} -inline void GetItem::SharedDtor(MessageLite& self) { - GetItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* GetItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) GetItem(arena); -} -constexpr auto GetItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(GetItem), - alignof(GetItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> GetItem::_class_data_ = { - { - &_GetItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &GetItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &GetItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &GetItem::ByteSizeLong, - &GetItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(GetItem, _impl_._cached_size_), - true, - }, - "dapi.commands.GetItem", -}; -const ::google::protobuf::internal::ClassData* GetItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> GetItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::GetItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(GetItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(GetItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void GetItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.GetItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* GetItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const GetItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* GetItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const GetItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.GetItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.GetItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t GetItem::ByteSizeLong(const MessageLite& base) { - const GetItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t GetItem::ByteSizeLong() const { - const GetItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.GetItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void GetItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.GetItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void GetItem::CopyFrom(const GetItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.GetItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void GetItem::InternalSwap(GetItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class SetSpell::_Internal { - public: -}; - -SetSpell::SetSpell(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SetSpell) -} -SetSpell::SetSpell( - ::google::protobuf::Arena* arena, const SetSpell& from) - : SetSpell(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SetSpell::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SetSpell::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, spellid_), - 0, - offsetof(Impl_, spelltype_) - - offsetof(Impl_, spellid_) + - sizeof(Impl_::spelltype_)); -} -SetSpell::~SetSpell() { - // @@protoc_insertion_point(destructor:dapi.commands.SetSpell) - SharedDtor(*this); -} -inline void SetSpell::SharedDtor(MessageLite& self) { - SetSpell& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SetSpell::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SetSpell(arena); -} -constexpr auto SetSpell::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SetSpell), - alignof(SetSpell)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<23> SetSpell::_class_data_ = { - { - &_SetSpell_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SetSpell::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SetSpell::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SetSpell::ByteSizeLong, - &SetSpell::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SetSpell, _impl_._cached_size_), - true, - }, - "dapi.commands.SetSpell", -}; -const ::google::protobuf::internal::ClassData* SetSpell::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 0, 2> SetSpell::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SetSpell>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // sint32 spellType = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_)}}, - // sint32 spellID = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 spellID = 1; - {PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 spellType = 2; - {PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SetSpell::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SetSpell) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.spellid_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.spelltype_) - - reinterpret_cast(&_impl_.spellid_)) + sizeof(_impl_.spelltype_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SetSpell::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SetSpell& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SetSpell::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SetSpell& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SetSpell) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 spellID = 1; - if (this_._internal_spellid() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_spellid(), target); - } - - // sint32 spellType = 2; - if (this_._internal_spelltype() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_spelltype(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SetSpell) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SetSpell::ByteSizeLong(const MessageLite& base) { - const SetSpell& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SetSpell::ByteSizeLong() const { - const SetSpell& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SetSpell) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // sint32 spellID = 1; - if (this_._internal_spellid() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_spellid()); - } - // sint32 spellType = 2; - if (this_._internal_spelltype() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_spelltype()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SetSpell::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SetSpell) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_spellid() != 0) { - _this->_impl_.spellid_ = from._impl_.spellid_; - } - if (from._internal_spelltype() != 0) { - _this->_impl_.spelltype_ = from._impl_.spelltype_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SetSpell::CopyFrom(const SetSpell& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SetSpell) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SetSpell::InternalSwap(SetSpell* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spelltype_) - + sizeof(SetSpell::_impl_.spelltype_) - - PROTOBUF_FIELD_OFFSET(SetSpell, _impl_.spellid_)>( - reinterpret_cast(&_impl_.spellid_), - reinterpret_cast(&other->_impl_.spellid_)); -} - -// =================================================================== - -class CastMonster::_Internal { - public: -}; - -CastMonster::CastMonster(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.CastMonster) -} -CastMonster::CastMonster( - ::google::protobuf::Arena* arena, const CastMonster& from) - : CastMonster(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE CastMonster::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void CastMonster::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.index_ = {}; -} -CastMonster::~CastMonster() { - // @@protoc_insertion_point(destructor:dapi.commands.CastMonster) - SharedDtor(*this); -} -inline void CastMonster::SharedDtor(MessageLite& self) { - CastMonster& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* CastMonster::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) CastMonster(arena); -} -constexpr auto CastMonster::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CastMonster), - alignof(CastMonster)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> CastMonster::_class_data_ = { - { - &_CastMonster_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &CastMonster::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &CastMonster::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &CastMonster::ByteSizeLong, - &CastMonster::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(CastMonster, _impl_._cached_size_), - true, - }, - "dapi.commands.CastMonster", -}; -const ::google::protobuf::internal::ClassData* CastMonster::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> CastMonster::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::CastMonster>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 index = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(CastMonster, _impl_.index_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 index = 1; - {PROTOBUF_FIELD_OFFSET(CastMonster, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void CastMonster::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.CastMonster) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* CastMonster::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const CastMonster& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* CastMonster::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const CastMonster& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CastMonster) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 index = 1; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CastMonster) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t CastMonster::ByteSizeLong(const MessageLite& base) { - const CastMonster& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t CastMonster::ByteSizeLong() const { - const CastMonster& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CastMonster) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 index = 1; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void CastMonster::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CastMonster) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void CastMonster::CopyFrom(const CastMonster& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CastMonster) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void CastMonster::InternalSwap(CastMonster* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.index_, other->_impl_.index_); -} - -// =================================================================== - -class CastXY::_Internal { - public: -}; - -CastXY::CastXY(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.CastXY) -} -CastXY::CastXY( - ::google::protobuf::Arena* arena, const CastXY& from) - : CastXY(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE CastXY::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void CastXY::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, x_), - 0, - offsetof(Impl_, y_) - - offsetof(Impl_, x_) + - sizeof(Impl_::y_)); -} -CastXY::~CastXY() { - // @@protoc_insertion_point(destructor:dapi.commands.CastXY) - SharedDtor(*this); -} -inline void CastXY::SharedDtor(MessageLite& self) { - CastXY& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* CastXY::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) CastXY(arena); -} -constexpr auto CastXY::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(CastXY), - alignof(CastXY)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> CastXY::_class_data_ = { - { - &_CastXY_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &CastXY::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &CastXY::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &CastXY::ByteSizeLong, - &CastXY::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(CastXY, _impl_._cached_size_), - true, - }, - "dapi.commands.CastXY", -}; -const ::google::protobuf::internal::ClassData* CastXY::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 0, 2> CastXY::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::CastXY>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // sint32 y = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_)}}, - // sint32 x = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 x = 1; - {PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 y = 2; - {PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void CastXY::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.CastXY) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.x_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.y_) - - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.y_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* CastXY::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const CastXY& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* CastXY::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const CastXY& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.CastXY) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 x = 1; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_x(), target); - } - - // sint32 y = 2; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_y(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.CastXY) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t CastXY::ByteSizeLong(const MessageLite& base) { - const CastXY& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t CastXY::ByteSizeLong() const { - const CastXY& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.CastXY) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // sint32 x = 1; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_x()); - } - // sint32 y = 2; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_y()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void CastXY::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.CastXY) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void CastXY::CopyFrom(const CastXY& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.CastXY) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void CastXY::InternalSwap(CastXY* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(CastXY, _impl_.y_) - + sizeof(CastXY::_impl_.y_) - - PROTOBUF_FIELD_OFFSET(CastXY, _impl_.x_)>( - reinterpret_cast(&_impl_.x_), - reinterpret_cast(&other->_impl_.x_)); -} - -// =================================================================== - -class ToggleInventory::_Internal { - public: -}; - -ToggleInventory::ToggleInventory(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleInventory) -} -ToggleInventory::ToggleInventory( - ::google::protobuf::Arena* arena, const ToggleInventory& from) - : ToggleInventory(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ToggleInventory::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ToggleInventory::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -ToggleInventory::~ToggleInventory() { - // @@protoc_insertion_point(destructor:dapi.commands.ToggleInventory) - SharedDtor(*this); -} -inline void ToggleInventory::SharedDtor(MessageLite& self) { - ToggleInventory& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ToggleInventory::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ToggleInventory(arena); -} -constexpr auto ToggleInventory::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleInventory), - alignof(ToggleInventory)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<30> ToggleInventory::_class_data_ = { - { - &_ToggleInventory_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ToggleInventory::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ToggleInventory::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ToggleInventory::ByteSizeLong, - &ToggleInventory::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ToggleInventory, _impl_._cached_size_), - true, - }, - "dapi.commands.ToggleInventory", -}; -const ::google::protobuf::internal::ClassData* ToggleInventory::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleInventory::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::ToggleInventory>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ToggleInventory::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleInventory) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ToggleInventory::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ToggleInventory& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ToggleInventory::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ToggleInventory& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleInventory) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleInventory) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ToggleInventory::ByteSizeLong(const MessageLite& base) { - const ToggleInventory& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ToggleInventory::ByteSizeLong() const { - const ToggleInventory& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleInventory) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ToggleInventory::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleInventory) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ToggleInventory::CopyFrom(const ToggleInventory& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleInventory) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ToggleInventory::InternalSwap(ToggleInventory* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class PutInCursor::_Internal { - public: -}; - -PutInCursor::PutInCursor(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.PutInCursor) -} -PutInCursor::PutInCursor( - ::google::protobuf::Arena* arena, const PutInCursor& from) - : PutInCursor(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE PutInCursor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void PutInCursor::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -PutInCursor::~PutInCursor() { - // @@protoc_insertion_point(destructor:dapi.commands.PutInCursor) - SharedDtor(*this); -} -inline void PutInCursor::SharedDtor(MessageLite& self) { - PutInCursor& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* PutInCursor::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) PutInCursor(arena); -} -constexpr auto PutInCursor::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PutInCursor), - alignof(PutInCursor)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> PutInCursor::_class_data_ = { - { - &_PutInCursor_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &PutInCursor::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &PutInCursor::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &PutInCursor::ByteSizeLong, - &PutInCursor::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_._cached_size_), - true, - }, - "dapi.commands.PutInCursor", -}; -const ::google::protobuf::internal::ClassData* PutInCursor::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> PutInCursor::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::PutInCursor>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(PutInCursor, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void PutInCursor::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.PutInCursor) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* PutInCursor::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const PutInCursor& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* PutInCursor::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const PutInCursor& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.PutInCursor) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.PutInCursor) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t PutInCursor::ByteSizeLong(const MessageLite& base) { - const PutInCursor& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t PutInCursor::ByteSizeLong() const { - const PutInCursor& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.PutInCursor) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void PutInCursor::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.PutInCursor) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void PutInCursor::CopyFrom(const PutInCursor& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.PutInCursor) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void PutInCursor::InternalSwap(PutInCursor* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class PutCursorItem::_Internal { - public: -}; - -PutCursorItem::PutCursorItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.PutCursorItem) -} -PutCursorItem::PutCursorItem( - ::google::protobuf::Arena* arena, const PutCursorItem& from) - : PutCursorItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE PutCursorItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void PutCursorItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.target_ = {}; -} -PutCursorItem::~PutCursorItem() { - // @@protoc_insertion_point(destructor:dapi.commands.PutCursorItem) - SharedDtor(*this); -} -inline void PutCursorItem::SharedDtor(MessageLite& self) { - PutCursorItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* PutCursorItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) PutCursorItem(arena); -} -constexpr auto PutCursorItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PutCursorItem), - alignof(PutCursorItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<28> PutCursorItem::_class_data_ = { - { - &_PutCursorItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &PutCursorItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &PutCursorItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &PutCursorItem::ByteSizeLong, - &PutCursorItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_._cached_size_), - true, - }, - "dapi.commands.PutCursorItem", -}; -const ::google::protobuf::internal::ClassData* PutCursorItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> PutCursorItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::PutCursorItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // sint32 target = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_.target_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 target = 1; - {PROTOBUF_FIELD_OFFSET(PutCursorItem, _impl_.target_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void PutCursorItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.PutCursorItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.target_ = 0; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* PutCursorItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const PutCursorItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* PutCursorItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const PutCursorItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.PutCursorItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 target = 1; - if (this_._internal_target() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_target(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.PutCursorItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t PutCursorItem::ByteSizeLong(const MessageLite& base) { - const PutCursorItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t PutCursorItem::ByteSizeLong() const { - const PutCursorItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.PutCursorItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // sint32 target = 1; - if (this_._internal_target() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_target()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void PutCursorItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.PutCursorItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_target() != 0) { - _this->_impl_.target_ = from._impl_.target_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void PutCursorItem::CopyFrom(const PutCursorItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.PutCursorItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void PutCursorItem::InternalSwap(PutCursorItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.target_, other->_impl_.target_); -} - -// =================================================================== - -class DropCursorItem::_Internal { - public: -}; - -DropCursorItem::DropCursorItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.DropCursorItem) -} -DropCursorItem::DropCursorItem( - ::google::protobuf::Arena* arena, const DropCursorItem& from) - : DropCursorItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE DropCursorItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void DropCursorItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -DropCursorItem::~DropCursorItem() { - // @@protoc_insertion_point(destructor:dapi.commands.DropCursorItem) - SharedDtor(*this); -} -inline void DropCursorItem::SharedDtor(MessageLite& self) { - DropCursorItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* DropCursorItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) DropCursorItem(arena); -} -constexpr auto DropCursorItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DropCursorItem), - alignof(DropCursorItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<29> DropCursorItem::_class_data_ = { - { - &_DropCursorItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &DropCursorItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &DropCursorItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &DropCursorItem::ByteSizeLong, - &DropCursorItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(DropCursorItem, _impl_._cached_size_), - true, - }, - "dapi.commands.DropCursorItem", -}; -const ::google::protobuf::internal::ClassData* DropCursorItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> DropCursorItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::DropCursorItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void DropCursorItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.DropCursorItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* DropCursorItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const DropCursorItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* DropCursorItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const DropCursorItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.DropCursorItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.DropCursorItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t DropCursorItem::ByteSizeLong(const MessageLite& base) { - const DropCursorItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t DropCursorItem::ByteSizeLong() const { - const DropCursorItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.DropCursorItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void DropCursorItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.DropCursorItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void DropCursorItem::CopyFrom(const DropCursorItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.DropCursorItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void DropCursorItem::InternalSwap(DropCursorItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class UseItem::_Internal { - public: -}; - -UseItem::UseItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.UseItem) -} -UseItem::UseItem( - ::google::protobuf::Arena* arena, const UseItem& from) - : UseItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE UseItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void UseItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -UseItem::~UseItem() { - // @@protoc_insertion_point(destructor:dapi.commands.UseItem) - SharedDtor(*this); -} -inline void UseItem::SharedDtor(MessageLite& self) { - UseItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* UseItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) UseItem(arena); -} -constexpr auto UseItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(UseItem), - alignof(UseItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> UseItem::_class_data_ = { - { - &_UseItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &UseItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &UseItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &UseItem::ByteSizeLong, - &UseItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(UseItem, _impl_._cached_size_), - true, - }, - "dapi.commands.UseItem", -}; -const ::google::protobuf::internal::ClassData* UseItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> UseItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::UseItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(UseItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(UseItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void UseItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.UseItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* UseItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const UseItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* UseItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const UseItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.UseItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.UseItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t UseItem::ByteSizeLong(const MessageLite& base) { - const UseItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t UseItem::ByteSizeLong() const { - const UseItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.UseItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void UseItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.UseItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void UseItem::CopyFrom(const UseItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.UseItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void UseItem::InternalSwap(UseItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class IdentifyStoreItem::_Internal { - public: -}; - -IdentifyStoreItem::IdentifyStoreItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.IdentifyStoreItem) -} -IdentifyStoreItem::IdentifyStoreItem( - ::google::protobuf::Arena* arena, const IdentifyStoreItem& from) - : IdentifyStoreItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE IdentifyStoreItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void IdentifyStoreItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -IdentifyStoreItem::~IdentifyStoreItem() { - // @@protoc_insertion_point(destructor:dapi.commands.IdentifyStoreItem) - SharedDtor(*this); -} -inline void IdentifyStoreItem::SharedDtor(MessageLite& self) { - IdentifyStoreItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* IdentifyStoreItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) IdentifyStoreItem(arena); -} -constexpr auto IdentifyStoreItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IdentifyStoreItem), - alignof(IdentifyStoreItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<32> IdentifyStoreItem::_class_data_ = { - { - &_IdentifyStoreItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &IdentifyStoreItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &IdentifyStoreItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &IdentifyStoreItem::ByteSizeLong, - &IdentifyStoreItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_._cached_size_), - true, - }, - "dapi.commands.IdentifyStoreItem", -}; -const ::google::protobuf::internal::ClassData* IdentifyStoreItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IdentifyStoreItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::IdentifyStoreItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(IdentifyStoreItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void IdentifyStoreItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.IdentifyStoreItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* IdentifyStoreItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const IdentifyStoreItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* IdentifyStoreItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const IdentifyStoreItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IdentifyStoreItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IdentifyStoreItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t IdentifyStoreItem::ByteSizeLong(const MessageLite& base) { - const IdentifyStoreItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t IdentifyStoreItem::ByteSizeLong() const { - const IdentifyStoreItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IdentifyStoreItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void IdentifyStoreItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IdentifyStoreItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void IdentifyStoreItem::CopyFrom(const IdentifyStoreItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IdentifyStoreItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void IdentifyStoreItem::InternalSwap(IdentifyStoreItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class DisarmTrap::_Internal { - public: -}; - -DisarmTrap::DisarmTrap(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.DisarmTrap) -} -DisarmTrap::DisarmTrap( - ::google::protobuf::Arena* arena, const DisarmTrap& from) - : DisarmTrap(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE DisarmTrap::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void DisarmTrap::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.index_ = {}; -} -DisarmTrap::~DisarmTrap() { - // @@protoc_insertion_point(destructor:dapi.commands.DisarmTrap) - SharedDtor(*this); -} -inline void DisarmTrap::SharedDtor(MessageLite& self) { - DisarmTrap& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* DisarmTrap::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) DisarmTrap(arena); -} -constexpr auto DisarmTrap::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(DisarmTrap), - alignof(DisarmTrap)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<25> DisarmTrap::_class_data_ = { - { - &_DisarmTrap_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &DisarmTrap::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &DisarmTrap::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &DisarmTrap::ByteSizeLong, - &DisarmTrap::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_._cached_size_), - true, - }, - "dapi.commands.DisarmTrap", -}; -const ::google::protobuf::internal::ClassData* DisarmTrap::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> DisarmTrap::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::DisarmTrap>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 index = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_.index_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 index = 1; - {PROTOBUF_FIELD_OFFSET(DisarmTrap, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void DisarmTrap::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.DisarmTrap) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.index_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* DisarmTrap::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const DisarmTrap& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* DisarmTrap::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const DisarmTrap& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.DisarmTrap) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 index = 1; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_index(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.DisarmTrap) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t DisarmTrap::ByteSizeLong(const MessageLite& base) { - const DisarmTrap& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t DisarmTrap::ByteSizeLong() const { - const DisarmTrap& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.DisarmTrap) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 index = 1; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void DisarmTrap::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.DisarmTrap) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void DisarmTrap::CopyFrom(const DisarmTrap& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.DisarmTrap) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void DisarmTrap::InternalSwap(DisarmTrap* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.index_, other->_impl_.index_); -} - -// =================================================================== - -class SkillRepair::_Internal { - public: -}; - -SkillRepair::SkillRepair(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SkillRepair) -} -SkillRepair::SkillRepair( - ::google::protobuf::Arena* arena, const SkillRepair& from) - : SkillRepair(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SkillRepair::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SkillRepair::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -SkillRepair::~SkillRepair() { - // @@protoc_insertion_point(destructor:dapi.commands.SkillRepair) - SharedDtor(*this); -} -inline void SkillRepair::SharedDtor(MessageLite& self) { - SkillRepair& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SkillRepair::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SkillRepair(arena); -} -constexpr auto SkillRepair::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SkillRepair), - alignof(SkillRepair)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> SkillRepair::_class_data_ = { - { - &_SkillRepair_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SkillRepair::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SkillRepair::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SkillRepair::ByteSizeLong, - &SkillRepair::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_._cached_size_), - true, - }, - "dapi.commands.SkillRepair", -}; -const ::google::protobuf::internal::ClassData* SkillRepair::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SkillRepair::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SkillRepair>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(SkillRepair, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SkillRepair::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SkillRepair) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SkillRepair::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SkillRepair& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SkillRepair::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SkillRepair& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SkillRepair) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SkillRepair) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SkillRepair::ByteSizeLong(const MessageLite& base) { - const SkillRepair& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SkillRepair::ByteSizeLong() const { - const SkillRepair& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SkillRepair) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SkillRepair::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SkillRepair) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SkillRepair::CopyFrom(const SkillRepair& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SkillRepair) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SkillRepair::InternalSwap(SkillRepair* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class SkillRecharge::_Internal { - public: -}; - -SkillRecharge::SkillRecharge(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SkillRecharge) -} -SkillRecharge::SkillRecharge( - ::google::protobuf::Arena* arena, const SkillRecharge& from) - : SkillRecharge(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SkillRecharge::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SkillRecharge::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -SkillRecharge::~SkillRecharge() { - // @@protoc_insertion_point(destructor:dapi.commands.SkillRecharge) - SharedDtor(*this); -} -inline void SkillRecharge::SharedDtor(MessageLite& self) { - SkillRecharge& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SkillRecharge::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SkillRecharge(arena); -} -constexpr auto SkillRecharge::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SkillRecharge), - alignof(SkillRecharge)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<28> SkillRecharge::_class_data_ = { - { - &_SkillRecharge_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SkillRecharge::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SkillRecharge::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SkillRecharge::ByteSizeLong, - &SkillRecharge::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_._cached_size_), - true, - }, - "dapi.commands.SkillRecharge", -}; -const ::google::protobuf::internal::ClassData* SkillRecharge::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> SkillRecharge::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SkillRecharge>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(SkillRecharge, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SkillRecharge::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SkillRecharge) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SkillRecharge::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SkillRecharge& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SkillRecharge::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SkillRecharge& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SkillRecharge) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SkillRecharge) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SkillRecharge::ByteSizeLong(const MessageLite& base) { - const SkillRecharge& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SkillRecharge::ByteSizeLong() const { - const SkillRecharge& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SkillRecharge) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SkillRecharge::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SkillRecharge) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SkillRecharge::CopyFrom(const SkillRecharge& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SkillRecharge) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SkillRecharge::InternalSwap(SkillRecharge* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class ToggleMenu::_Internal { - public: -}; - -ToggleMenu::ToggleMenu(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.ToggleMenu) -} -ToggleMenu::ToggleMenu( - ::google::protobuf::Arena* arena, const ToggleMenu& from) - : ToggleMenu(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ToggleMenu::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ToggleMenu::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -ToggleMenu::~ToggleMenu() { - // @@protoc_insertion_point(destructor:dapi.commands.ToggleMenu) - SharedDtor(*this); -} -inline void ToggleMenu::SharedDtor(MessageLite& self) { - ToggleMenu& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ToggleMenu::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ToggleMenu(arena); -} -constexpr auto ToggleMenu::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ToggleMenu), - alignof(ToggleMenu)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<25> ToggleMenu::_class_data_ = { - { - &_ToggleMenu_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ToggleMenu::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ToggleMenu::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ToggleMenu::ByteSizeLong, - &ToggleMenu::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ToggleMenu, _impl_._cached_size_), - true, - }, - "dapi.commands.ToggleMenu", -}; -const ::google::protobuf::internal::ClassData* ToggleMenu::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ToggleMenu::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::ToggleMenu>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ToggleMenu::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.ToggleMenu) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ToggleMenu::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ToggleMenu& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ToggleMenu::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ToggleMenu& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ToggleMenu) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ToggleMenu) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ToggleMenu::ByteSizeLong(const MessageLite& base) { - const ToggleMenu& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ToggleMenu::ByteSizeLong() const { - const ToggleMenu& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ToggleMenu) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ToggleMenu::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ToggleMenu) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ToggleMenu::CopyFrom(const ToggleMenu& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ToggleMenu) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ToggleMenu::InternalSwap(ToggleMenu* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class SaveGame::_Internal { - public: -}; - -SaveGame::SaveGame(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.SaveGame) -} -SaveGame::SaveGame( - ::google::protobuf::Arena* arena, const SaveGame& from) - : SaveGame(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE SaveGame::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void SaveGame::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -SaveGame::~SaveGame() { - // @@protoc_insertion_point(destructor:dapi.commands.SaveGame) - SharedDtor(*this); -} -inline void SaveGame::SharedDtor(MessageLite& self) { - SaveGame& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* SaveGame::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) SaveGame(arena); -} -constexpr auto SaveGame::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(SaveGame), - alignof(SaveGame)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<23> SaveGame::_class_data_ = { - { - &_SaveGame_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &SaveGame::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &SaveGame::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &SaveGame::ByteSizeLong, - &SaveGame::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(SaveGame, _impl_._cached_size_), - true, - }, - "dapi.commands.SaveGame", -}; -const ::google::protobuf::internal::ClassData* SaveGame::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> SaveGame::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::SaveGame>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void SaveGame::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.SaveGame) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* SaveGame::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const SaveGame& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* SaveGame::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const SaveGame& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.SaveGame) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.SaveGame) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t SaveGame::ByteSizeLong(const MessageLite& base) { - const SaveGame& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t SaveGame::ByteSizeLong() const { - const SaveGame& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.SaveGame) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void SaveGame::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.SaveGame) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void SaveGame::CopyFrom(const SaveGame& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.SaveGame) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void SaveGame::InternalSwap(SaveGame* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class Quit::_Internal { - public: -}; - -Quit::Quit(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.Quit) -} -Quit::Quit( - ::google::protobuf::Arena* arena, const Quit& from) - : Quit(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE Quit::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void Quit::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -Quit::~Quit() { - // @@protoc_insertion_point(destructor:dapi.commands.Quit) - SharedDtor(*this); -} -inline void Quit::SharedDtor(MessageLite& self) { - Quit& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* Quit::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) Quit(arena); -} -constexpr auto Quit::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Quit), - alignof(Quit)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<19> Quit::_class_data_ = { - { - &_Quit_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &Quit::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &Quit::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &Quit::ByteSizeLong, - &Quit::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(Quit, _impl_._cached_size_), - true, - }, - "dapi.commands.Quit", -}; -const ::google::protobuf::internal::ClassData* Quit::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> Quit::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::Quit>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void Quit::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.Quit) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* Quit::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const Quit& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* Quit::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const Quit& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Quit) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Quit) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t Quit::ByteSizeLong(const MessageLite& base) { - const Quit& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t Quit::ByteSizeLong() const { - const Quit& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Quit) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void Quit::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Quit) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void Quit::CopyFrom(const Quit& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Quit) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void Quit::InternalSwap(Quit* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class ClearCursor::_Internal { - public: -}; - -ClearCursor::ClearCursor(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.ClearCursor) -} -ClearCursor::ClearCursor( - ::google::protobuf::Arena* arena, const ClearCursor& from) - : ClearCursor(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ClearCursor::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ClearCursor::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -ClearCursor::~ClearCursor() { - // @@protoc_insertion_point(destructor:dapi.commands.ClearCursor) - SharedDtor(*this); -} -inline void ClearCursor::SharedDtor(MessageLite& self) { - ClearCursor& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ClearCursor::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ClearCursor(arena); -} -constexpr auto ClearCursor::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ClearCursor), - alignof(ClearCursor)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> ClearCursor::_class_data_ = { - { - &_ClearCursor_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ClearCursor::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ClearCursor::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ClearCursor::ByteSizeLong, - &ClearCursor::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ClearCursor, _impl_._cached_size_), - true, - }, - "dapi.commands.ClearCursor", -}; -const ::google::protobuf::internal::ClassData* ClearCursor::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ClearCursor::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::ClearCursor>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ClearCursor::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.ClearCursor) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ClearCursor::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ClearCursor& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ClearCursor::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ClearCursor& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.ClearCursor) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.ClearCursor) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ClearCursor::ByteSizeLong(const MessageLite& base) { - const ClearCursor& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ClearCursor::ByteSizeLong() const { - const ClearCursor& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.ClearCursor) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ClearCursor::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.ClearCursor) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ClearCursor::CopyFrom(const ClearCursor& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.ClearCursor) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ClearCursor::InternalSwap(ClearCursor* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class IdentifyItem::_Internal { - public: -}; - -IdentifyItem::IdentifyItem(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.IdentifyItem) -} -IdentifyItem::IdentifyItem( - ::google::protobuf::Arena* arena, const IdentifyItem& from) - : IdentifyItem(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE IdentifyItem::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void IdentifyItem::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.id_ = {}; -} -IdentifyItem::~IdentifyItem() { - // @@protoc_insertion_point(destructor:dapi.commands.IdentifyItem) - SharedDtor(*this); -} -inline void IdentifyItem::SharedDtor(MessageLite& self) { - IdentifyItem& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* IdentifyItem::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) IdentifyItem(arena); -} -constexpr auto IdentifyItem::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(IdentifyItem), - alignof(IdentifyItem)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<27> IdentifyItem::_class_data_ = { - { - &_IdentifyItem_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &IdentifyItem::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &IdentifyItem::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &IdentifyItem::ByteSizeLong, - &IdentifyItem::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_._cached_size_), - true, - }, - "dapi.commands.IdentifyItem", -}; -const ::google::protobuf::internal::ClassData* IdentifyItem::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> IdentifyItem::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::IdentifyItem>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(IdentifyItem, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void IdentifyItem::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.IdentifyItem) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.id_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* IdentifyItem::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const IdentifyItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* IdentifyItem::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const IdentifyItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.IdentifyItem) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.IdentifyItem) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t IdentifyItem::ByteSizeLong(const MessageLite& base) { - const IdentifyItem& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t IdentifyItem::ByteSizeLong() const { - const IdentifyItem& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.IdentifyItem) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void IdentifyItem::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.IdentifyItem) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void IdentifyItem::CopyFrom(const IdentifyItem& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.IdentifyItem) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void IdentifyItem::InternalSwap(IdentifyItem* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.id_, other->_impl_.id_); -} - -// =================================================================== - -class Command::_Internal { - public: - static constexpr ::int32_t kOneofCaseOffset = - PROTOBUF_FIELD_OFFSET(::dapi::commands::Command, _impl_._oneof_case_); -}; - -void Command::set_allocated_move(::dapi::commands::Move* move) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (move) { - ::google::protobuf::Arena* submessage_arena = move->GetArena(); - if (message_arena != submessage_arena) { - move = ::google::protobuf::internal::GetOwnedMessage(message_arena, move, submessage_arena); - } - set_has_move(); - _impl_.command_.move_ = move; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.move) -} -void Command::set_allocated_talk(::dapi::commands::Talk* talk) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (talk) { - ::google::protobuf::Arena* submessage_arena = talk->GetArena(); - if (message_arena != submessage_arena) { - talk = ::google::protobuf::internal::GetOwnedMessage(message_arena, talk, submessage_arena); - } - set_has_talk(); - _impl_.command_.talk_ = talk; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.talk) -} -void Command::set_allocated_option(::dapi::commands::SelectStoreOption* option) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (option) { - ::google::protobuf::Arena* submessage_arena = option->GetArena(); - if (message_arena != submessage_arena) { - option = ::google::protobuf::internal::GetOwnedMessage(message_arena, option, submessage_arena); - } - set_has_option(); - _impl_.command_.option_ = option; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.option) -} -void Command::set_allocated_buyitem(::dapi::commands::BuyItem* buyitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (buyitem) { - ::google::protobuf::Arena* submessage_arena = buyitem->GetArena(); - if (message_arena != submessage_arena) { - buyitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, buyitem, submessage_arena); - } - set_has_buyitem(); - _impl_.command_.buyitem_ = buyitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.buyItem) -} -void Command::set_allocated_sellitem(::dapi::commands::SellItem* sellitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (sellitem) { - ::google::protobuf::Arena* submessage_arena = sellitem->GetArena(); - if (message_arena != submessage_arena) { - sellitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, sellitem, submessage_arena); - } - set_has_sellitem(); - _impl_.command_.sellitem_ = sellitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.sellItem) -} -void Command::set_allocated_rechargeitem(::dapi::commands::RechargeItem* rechargeitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (rechargeitem) { - ::google::protobuf::Arena* submessage_arena = rechargeitem->GetArena(); - if (message_arena != submessage_arena) { - rechargeitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, rechargeitem, submessage_arena); - } - set_has_rechargeitem(); - _impl_.command_.rechargeitem_ = rechargeitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.rechargeItem) -} -void Command::set_allocated_repairitem(::dapi::commands::RepairItem* repairitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (repairitem) { - ::google::protobuf::Arena* submessage_arena = repairitem->GetArena(); - if (message_arena != submessage_arena) { - repairitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, repairitem, submessage_arena); - } - set_has_repairitem(); - _impl_.command_.repairitem_ = repairitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.repairItem) -} -void Command::set_allocated_attackmonster(::dapi::commands::AttackMonster* attackmonster) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (attackmonster) { - ::google::protobuf::Arena* submessage_arena = attackmonster->GetArena(); - if (message_arena != submessage_arena) { - attackmonster = ::google::protobuf::internal::GetOwnedMessage(message_arena, attackmonster, submessage_arena); - } - set_has_attackmonster(); - _impl_.command_.attackmonster_ = attackmonster; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.attackMonster) -} -void Command::set_allocated_attackxy(::dapi::commands::AttackXY* attackxy) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (attackxy) { - ::google::protobuf::Arena* submessage_arena = attackxy->GetArena(); - if (message_arena != submessage_arena) { - attackxy = ::google::protobuf::internal::GetOwnedMessage(message_arena, attackxy, submessage_arena); - } - set_has_attackxy(); - _impl_.command_.attackxy_ = attackxy; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.attackXY) -} -void Command::set_allocated_operateobject(::dapi::commands::OperateObject* operateobject) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (operateobject) { - ::google::protobuf::Arena* submessage_arena = operateobject->GetArena(); - if (message_arena != submessage_arena) { - operateobject = ::google::protobuf::internal::GetOwnedMessage(message_arena, operateobject, submessage_arena); - } - set_has_operateobject(); - _impl_.command_.operateobject_ = operateobject; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.operateObject) -} -void Command::set_allocated_usebeltitem(::dapi::commands::UseBeltItem* usebeltitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (usebeltitem) { - ::google::protobuf::Arena* submessage_arena = usebeltitem->GetArena(); - if (message_arena != submessage_arena) { - usebeltitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, usebeltitem, submessage_arena); - } - set_has_usebeltitem(); - _impl_.command_.usebeltitem_ = usebeltitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.useBeltItem) -} -void Command::set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* togglecharactersheet) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (togglecharactersheet) { - ::google::protobuf::Arena* submessage_arena = togglecharactersheet->GetArena(); - if (message_arena != submessage_arena) { - togglecharactersheet = ::google::protobuf::internal::GetOwnedMessage(message_arena, togglecharactersheet, submessage_arena); - } - set_has_togglecharactersheet(); - _impl_.command_.togglecharactersheet_ = togglecharactersheet; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleCharacterSheet) -} -void Command::set_allocated_increasestat(::dapi::commands::IncreaseStat* increasestat) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (increasestat) { - ::google::protobuf::Arena* submessage_arena = increasestat->GetArena(); - if (message_arena != submessage_arena) { - increasestat = ::google::protobuf::internal::GetOwnedMessage(message_arena, increasestat, submessage_arena); - } - set_has_increasestat(); - _impl_.command_.increasestat_ = increasestat; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.increaseStat) -} -void Command::set_allocated_getitem(::dapi::commands::GetItem* getitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (getitem) { - ::google::protobuf::Arena* submessage_arena = getitem->GetArena(); - if (message_arena != submessage_arena) { - getitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, getitem, submessage_arena); - } - set_has_getitem(); - _impl_.command_.getitem_ = getitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.getItem) -} -void Command::set_allocated_setspell(::dapi::commands::SetSpell* setspell) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (setspell) { - ::google::protobuf::Arena* submessage_arena = setspell->GetArena(); - if (message_arena != submessage_arena) { - setspell = ::google::protobuf::internal::GetOwnedMessage(message_arena, setspell, submessage_arena); - } - set_has_setspell(); - _impl_.command_.setspell_ = setspell; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.setSpell) -} -void Command::set_allocated_castmonster(::dapi::commands::CastMonster* castmonster) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (castmonster) { - ::google::protobuf::Arena* submessage_arena = castmonster->GetArena(); - if (message_arena != submessage_arena) { - castmonster = ::google::protobuf::internal::GetOwnedMessage(message_arena, castmonster, submessage_arena); - } - set_has_castmonster(); - _impl_.command_.castmonster_ = castmonster; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.castMonster) -} -void Command::set_allocated_castxy(::dapi::commands::CastXY* castxy) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (castxy) { - ::google::protobuf::Arena* submessage_arena = castxy->GetArena(); - if (message_arena != submessage_arena) { - castxy = ::google::protobuf::internal::GetOwnedMessage(message_arena, castxy, submessage_arena); - } - set_has_castxy(); - _impl_.command_.castxy_ = castxy; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.castXY) -} -void Command::set_allocated_toggleinventory(::dapi::commands::ToggleInventory* toggleinventory) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (toggleinventory) { - ::google::protobuf::Arena* submessage_arena = toggleinventory->GetArena(); - if (message_arena != submessage_arena) { - toggleinventory = ::google::protobuf::internal::GetOwnedMessage(message_arena, toggleinventory, submessage_arena); - } - set_has_toggleinventory(); - _impl_.command_.toggleinventory_ = toggleinventory; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleInventory) -} -void Command::set_allocated_putincursor(::dapi::commands::PutInCursor* putincursor) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (putincursor) { - ::google::protobuf::Arena* submessage_arena = putincursor->GetArena(); - if (message_arena != submessage_arena) { - putincursor = ::google::protobuf::internal::GetOwnedMessage(message_arena, putincursor, submessage_arena); - } - set_has_putincursor(); - _impl_.command_.putincursor_ = putincursor; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.putInCursor) -} -void Command::set_allocated_putcursoritem(::dapi::commands::PutCursorItem* putcursoritem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (putcursoritem) { - ::google::protobuf::Arena* submessage_arena = putcursoritem->GetArena(); - if (message_arena != submessage_arena) { - putcursoritem = ::google::protobuf::internal::GetOwnedMessage(message_arena, putcursoritem, submessage_arena); - } - set_has_putcursoritem(); - _impl_.command_.putcursoritem_ = putcursoritem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.putCursorItem) -} -void Command::set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* dropcursoritem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (dropcursoritem) { - ::google::protobuf::Arena* submessage_arena = dropcursoritem->GetArena(); - if (message_arena != submessage_arena) { - dropcursoritem = ::google::protobuf::internal::GetOwnedMessage(message_arena, dropcursoritem, submessage_arena); - } - set_has_dropcursoritem(); - _impl_.command_.dropcursoritem_ = dropcursoritem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.dropCursorItem) -} -void Command::set_allocated_useitem(::dapi::commands::UseItem* useitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (useitem) { - ::google::protobuf::Arena* submessage_arena = useitem->GetArena(); - if (message_arena != submessage_arena) { - useitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, useitem, submessage_arena); - } - set_has_useitem(); - _impl_.command_.useitem_ = useitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.useItem) -} -void Command::set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* identifystoreitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (identifystoreitem) { - ::google::protobuf::Arena* submessage_arena = identifystoreitem->GetArena(); - if (message_arena != submessage_arena) { - identifystoreitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, identifystoreitem, submessage_arena); - } - set_has_identifystoreitem(); - _impl_.command_.identifystoreitem_ = identifystoreitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.identifyStoreItem) -} -void Command::set_allocated_cancelqtext(::dapi::commands::CancelQText* cancelqtext) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (cancelqtext) { - ::google::protobuf::Arena* submessage_arena = cancelqtext->GetArena(); - if (message_arena != submessage_arena) { - cancelqtext = ::google::protobuf::internal::GetOwnedMessage(message_arena, cancelqtext, submessage_arena); - } - set_has_cancelqtext(); - _impl_.command_.cancelqtext_ = cancelqtext; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.cancelQText) -} -void Command::set_allocated_setfps(::dapi::commands::SetFPS* setfps) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (setfps) { - ::google::protobuf::Arena* submessage_arena = setfps->GetArena(); - if (message_arena != submessage_arena) { - setfps = ::google::protobuf::internal::GetOwnedMessage(message_arena, setfps, submessage_arena); - } - set_has_setfps(); - _impl_.command_.setfps_ = setfps; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.setFPS) -} -void Command::set_allocated_disarmtrap(::dapi::commands::DisarmTrap* disarmtrap) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (disarmtrap) { - ::google::protobuf::Arena* submessage_arena = disarmtrap->GetArena(); - if (message_arena != submessage_arena) { - disarmtrap = ::google::protobuf::internal::GetOwnedMessage(message_arena, disarmtrap, submessage_arena); - } - set_has_disarmtrap(); - _impl_.command_.disarmtrap_ = disarmtrap; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.disarmTrap) -} -void Command::set_allocated_skillrepair(::dapi::commands::SkillRepair* skillrepair) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (skillrepair) { - ::google::protobuf::Arena* submessage_arena = skillrepair->GetArena(); - if (message_arena != submessage_arena) { - skillrepair = ::google::protobuf::internal::GetOwnedMessage(message_arena, skillrepair, submessage_arena); - } - set_has_skillrepair(); - _impl_.command_.skillrepair_ = skillrepair; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.skillRepair) -} -void Command::set_allocated_skillrecharge(::dapi::commands::SkillRecharge* skillrecharge) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (skillrecharge) { - ::google::protobuf::Arena* submessage_arena = skillrecharge->GetArena(); - if (message_arena != submessage_arena) { - skillrecharge = ::google::protobuf::internal::GetOwnedMessage(message_arena, skillrecharge, submessage_arena); - } - set_has_skillrecharge(); - _impl_.command_.skillrecharge_ = skillrecharge; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.skillRecharge) -} -void Command::set_allocated_togglemenu(::dapi::commands::ToggleMenu* togglemenu) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (togglemenu) { - ::google::protobuf::Arena* submessage_arena = togglemenu->GetArena(); - if (message_arena != submessage_arena) { - togglemenu = ::google::protobuf::internal::GetOwnedMessage(message_arena, togglemenu, submessage_arena); - } - set_has_togglemenu(); - _impl_.command_.togglemenu_ = togglemenu; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.toggleMenu) -} -void Command::set_allocated_savegame(::dapi::commands::SaveGame* savegame) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (savegame) { - ::google::protobuf::Arena* submessage_arena = savegame->GetArena(); - if (message_arena != submessage_arena) { - savegame = ::google::protobuf::internal::GetOwnedMessage(message_arena, savegame, submessage_arena); - } - set_has_savegame(); - _impl_.command_.savegame_ = savegame; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.saveGame) -} -void Command::set_allocated_quit(::dapi::commands::Quit* quit) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (quit) { - ::google::protobuf::Arena* submessage_arena = quit->GetArena(); - if (message_arena != submessage_arena) { - quit = ::google::protobuf::internal::GetOwnedMessage(message_arena, quit, submessage_arena); - } - set_has_quit(); - _impl_.command_.quit_ = quit; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.quit) -} -void Command::set_allocated_clearcursor(::dapi::commands::ClearCursor* clearcursor) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (clearcursor) { - ::google::protobuf::Arena* submessage_arena = clearcursor->GetArena(); - if (message_arena != submessage_arena) { - clearcursor = ::google::protobuf::internal::GetOwnedMessage(message_arena, clearcursor, submessage_arena); - } - set_has_clearcursor(); - _impl_.command_.clearcursor_ = clearcursor; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.clearCursor) -} -void Command::set_allocated_identifyitem(::dapi::commands::IdentifyItem* identifyitem) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_command(); - if (identifyitem) { - ::google::protobuf::Arena* submessage_arena = identifyitem->GetArena(); - if (message_arena != submessage_arena) { - identifyitem = ::google::protobuf::internal::GetOwnedMessage(message_arena, identifyitem, submessage_arena); - } - set_has_identifyitem(); - _impl_.command_.identifyitem_ = identifyitem; - } - // @@protoc_insertion_point(field_set_allocated:dapi.commands.Command.identifyItem) -} -Command::Command(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.commands.Command) -} -inline PROTOBUF_NDEBUG_INLINE Command::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::commands::Command& from_msg) - : command_{}, - _cached_size_{0}, - _oneof_case_{from._oneof_case_[0]} {} - -Command::Command( - ::google::protobuf::Arena* arena, - const Command& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - Command* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - switch (command_case()) { - case COMMAND_NOT_SET: - break; - case kMove: - _impl_.command_.move_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Move>(arena, *from._impl_.command_.move_); - break; - case kTalk: - _impl_.command_.talk_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Talk>(arena, *from._impl_.command_.talk_); - break; - case kOption: - _impl_.command_.option_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SelectStoreOption>(arena, *from._impl_.command_.option_); - break; - case kBuyItem: - _impl_.command_.buyitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::BuyItem>(arena, *from._impl_.command_.buyitem_); - break; - case kSellItem: - _impl_.command_.sellitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SellItem>(arena, *from._impl_.command_.sellitem_); - break; - case kRechargeItem: - _impl_.command_.rechargeitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RechargeItem>(arena, *from._impl_.command_.rechargeitem_); - break; - case kRepairItem: - _impl_.command_.repairitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RepairItem>(arena, *from._impl_.command_.repairitem_); - break; - case kAttackMonster: - _impl_.command_.attackmonster_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackMonster>(arena, *from._impl_.command_.attackmonster_); - break; - case kAttackXY: - _impl_.command_.attackxy_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackXY>(arena, *from._impl_.command_.attackxy_); - break; - case kOperateObject: - _impl_.command_.operateobject_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::OperateObject>(arena, *from._impl_.command_.operateobject_); - break; - case kUseBeltItem: - _impl_.command_.usebeltitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseBeltItem>(arena, *from._impl_.command_.usebeltitem_); - break; - case kToggleCharacterSheet: - _impl_.command_.togglecharactersheet_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleCharacterSheet>(arena, *from._impl_.command_.togglecharactersheet_); - break; - case kIncreaseStat: - _impl_.command_.increasestat_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IncreaseStat>(arena, *from._impl_.command_.increasestat_); - break; - case kGetItem: - _impl_.command_.getitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::GetItem>(arena, *from._impl_.command_.getitem_); - break; - case kSetSpell: - _impl_.command_.setspell_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetSpell>(arena, *from._impl_.command_.setspell_); - break; - case kCastMonster: - _impl_.command_.castmonster_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastMonster>(arena, *from._impl_.command_.castmonster_); - break; - case kCastXY: - _impl_.command_.castxy_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastXY>(arena, *from._impl_.command_.castxy_); - break; - case kToggleInventory: - _impl_.command_.toggleinventory_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleInventory>(arena, *from._impl_.command_.toggleinventory_); - break; - case kPutInCursor: - _impl_.command_.putincursor_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutInCursor>(arena, *from._impl_.command_.putincursor_); - break; - case kPutCursorItem: - _impl_.command_.putcursoritem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutCursorItem>(arena, *from._impl_.command_.putcursoritem_); - break; - case kDropCursorItem: - _impl_.command_.dropcursoritem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DropCursorItem>(arena, *from._impl_.command_.dropcursoritem_); - break; - case kUseItem: - _impl_.command_.useitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseItem>(arena, *from._impl_.command_.useitem_); - break; - case kIdentifyStoreItem: - _impl_.command_.identifystoreitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyStoreItem>(arena, *from._impl_.command_.identifystoreitem_); - break; - case kCancelQText: - _impl_.command_.cancelqtext_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CancelQText>(arena, *from._impl_.command_.cancelqtext_); - break; - case kSetFPS: - _impl_.command_.setfps_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetFPS>(arena, *from._impl_.command_.setfps_); - break; - case kDisarmTrap: - _impl_.command_.disarmtrap_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DisarmTrap>(arena, *from._impl_.command_.disarmtrap_); - break; - case kSkillRepair: - _impl_.command_.skillrepair_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRepair>(arena, *from._impl_.command_.skillrepair_); - break; - case kSkillRecharge: - _impl_.command_.skillrecharge_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRecharge>(arena, *from._impl_.command_.skillrecharge_); - break; - case kToggleMenu: - _impl_.command_.togglemenu_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleMenu>(arena, *from._impl_.command_.togglemenu_); - break; - case kSaveGame: - _impl_.command_.savegame_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SaveGame>(arena, *from._impl_.command_.savegame_); - break; - case kQuit: - _impl_.command_.quit_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Quit>(arena, *from._impl_.command_.quit_); - break; - case kClearCursor: - _impl_.command_.clearcursor_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ClearCursor>(arena, *from._impl_.command_.clearcursor_); - break; - case kIdentifyItem: - _impl_.command_.identifyitem_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyItem>(arena, *from._impl_.command_.identifyitem_); - break; - } - - // @@protoc_insertion_point(copy_constructor:dapi.commands.Command) -} -inline PROTOBUF_NDEBUG_INLINE Command::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : command_{}, - _cached_size_{0}, - _oneof_case_{} {} - -inline void Command::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -Command::~Command() { - // @@protoc_insertion_point(destructor:dapi.commands.Command) - SharedDtor(*this); -} -inline void Command::SharedDtor(MessageLite& self) { - Command& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - if (this_.has_command()) { - this_.clear_command(); - } - this_._impl_.~Impl_(); -} - -void Command::clear_command() { -// @@protoc_insertion_point(one_of_clear_start:dapi.commands.Command) - ::google::protobuf::internal::TSanWrite(&_impl_); - switch (command_case()) { - case kMove: { - if (GetArena() == nullptr) { - delete _impl_.command_.move_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.move_ != nullptr) { - _impl_.command_.move_->Clear(); - } - } - break; - } - case kTalk: { - if (GetArena() == nullptr) { - delete _impl_.command_.talk_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.talk_ != nullptr) { - _impl_.command_.talk_->Clear(); - } - } - break; - } - case kOption: { - if (GetArena() == nullptr) { - delete _impl_.command_.option_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.option_ != nullptr) { - _impl_.command_.option_->Clear(); - } - } - break; - } - case kBuyItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.buyitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.buyitem_ != nullptr) { - _impl_.command_.buyitem_->Clear(); - } - } - break; - } - case kSellItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.sellitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.sellitem_ != nullptr) { - _impl_.command_.sellitem_->Clear(); - } - } - break; - } - case kRechargeItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.rechargeitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.rechargeitem_ != nullptr) { - _impl_.command_.rechargeitem_->Clear(); - } - } - break; - } - case kRepairItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.repairitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.repairitem_ != nullptr) { - _impl_.command_.repairitem_->Clear(); - } - } - break; - } - case kAttackMonster: { - if (GetArena() == nullptr) { - delete _impl_.command_.attackmonster_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.attackmonster_ != nullptr) { - _impl_.command_.attackmonster_->Clear(); - } - } - break; - } - case kAttackXY: { - if (GetArena() == nullptr) { - delete _impl_.command_.attackxy_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.attackxy_ != nullptr) { - _impl_.command_.attackxy_->Clear(); - } - } - break; - } - case kOperateObject: { - if (GetArena() == nullptr) { - delete _impl_.command_.operateobject_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.operateobject_ != nullptr) { - _impl_.command_.operateobject_->Clear(); - } - } - break; - } - case kUseBeltItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.usebeltitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.usebeltitem_ != nullptr) { - _impl_.command_.usebeltitem_->Clear(); - } - } - break; - } - case kToggleCharacterSheet: { - if (GetArena() == nullptr) { - delete _impl_.command_.togglecharactersheet_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.togglecharactersheet_ != nullptr) { - _impl_.command_.togglecharactersheet_->Clear(); - } - } - break; - } - case kIncreaseStat: { - if (GetArena() == nullptr) { - delete _impl_.command_.increasestat_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.increasestat_ != nullptr) { - _impl_.command_.increasestat_->Clear(); - } - } - break; - } - case kGetItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.getitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.getitem_ != nullptr) { - _impl_.command_.getitem_->Clear(); - } - } - break; - } - case kSetSpell: { - if (GetArena() == nullptr) { - delete _impl_.command_.setspell_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.setspell_ != nullptr) { - _impl_.command_.setspell_->Clear(); - } - } - break; - } - case kCastMonster: { - if (GetArena() == nullptr) { - delete _impl_.command_.castmonster_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.castmonster_ != nullptr) { - _impl_.command_.castmonster_->Clear(); - } - } - break; - } - case kCastXY: { - if (GetArena() == nullptr) { - delete _impl_.command_.castxy_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.castxy_ != nullptr) { - _impl_.command_.castxy_->Clear(); - } - } - break; - } - case kToggleInventory: { - if (GetArena() == nullptr) { - delete _impl_.command_.toggleinventory_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.toggleinventory_ != nullptr) { - _impl_.command_.toggleinventory_->Clear(); - } - } - break; - } - case kPutInCursor: { - if (GetArena() == nullptr) { - delete _impl_.command_.putincursor_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.putincursor_ != nullptr) { - _impl_.command_.putincursor_->Clear(); - } - } - break; - } - case kPutCursorItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.putcursoritem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.putcursoritem_ != nullptr) { - _impl_.command_.putcursoritem_->Clear(); - } - } - break; - } - case kDropCursorItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.dropcursoritem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.dropcursoritem_ != nullptr) { - _impl_.command_.dropcursoritem_->Clear(); - } - } - break; - } - case kUseItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.useitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.useitem_ != nullptr) { - _impl_.command_.useitem_->Clear(); - } - } - break; - } - case kIdentifyStoreItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.identifystoreitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.identifystoreitem_ != nullptr) { - _impl_.command_.identifystoreitem_->Clear(); - } - } - break; - } - case kCancelQText: { - if (GetArena() == nullptr) { - delete _impl_.command_.cancelqtext_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.cancelqtext_ != nullptr) { - _impl_.command_.cancelqtext_->Clear(); - } - } - break; - } - case kSetFPS: { - if (GetArena() == nullptr) { - delete _impl_.command_.setfps_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.setfps_ != nullptr) { - _impl_.command_.setfps_->Clear(); - } - } - break; - } - case kDisarmTrap: { - if (GetArena() == nullptr) { - delete _impl_.command_.disarmtrap_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.disarmtrap_ != nullptr) { - _impl_.command_.disarmtrap_->Clear(); - } - } - break; - } - case kSkillRepair: { - if (GetArena() == nullptr) { - delete _impl_.command_.skillrepair_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.skillrepair_ != nullptr) { - _impl_.command_.skillrepair_->Clear(); - } - } - break; - } - case kSkillRecharge: { - if (GetArena() == nullptr) { - delete _impl_.command_.skillrecharge_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.skillrecharge_ != nullptr) { - _impl_.command_.skillrecharge_->Clear(); - } - } - break; - } - case kToggleMenu: { - if (GetArena() == nullptr) { - delete _impl_.command_.togglemenu_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.togglemenu_ != nullptr) { - _impl_.command_.togglemenu_->Clear(); - } - } - break; - } - case kSaveGame: { - if (GetArena() == nullptr) { - delete _impl_.command_.savegame_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.savegame_ != nullptr) { - _impl_.command_.savegame_->Clear(); - } - } - break; - } - case kQuit: { - if (GetArena() == nullptr) { - delete _impl_.command_.quit_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.quit_ != nullptr) { - _impl_.command_.quit_->Clear(); - } - } - break; - } - case kClearCursor: { - if (GetArena() == nullptr) { - delete _impl_.command_.clearcursor_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.clearcursor_ != nullptr) { - _impl_.command_.clearcursor_->Clear(); - } - } - break; - } - case kIdentifyItem: { - if (GetArena() == nullptr) { - delete _impl_.command_.identifyitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.identifyitem_ != nullptr) { - _impl_.command_.identifyitem_->Clear(); - } - } - break; - } - case COMMAND_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = COMMAND_NOT_SET; -} - - -inline void* Command::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) Command(arena); -} -constexpr auto Command::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Command), - alignof(Command)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> Command::_class_data_ = { - { - &_Command_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &Command::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &Command::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &Command::ByteSizeLong, - &Command::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(Command, _impl_._cached_size_), - true, - }, - "dapi.commands.Command", -}; -const ::google::protobuf::internal::ClassData* Command::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 33, 33, 0, 7> Command::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 33, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 0, // skipmap - offsetof(decltype(_table_), field_entries), - 33, // num_field_entries - 33, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::commands::Command>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 33, 0, 1, - 65534, 32, - 65535, 65535 - }}, {{ - // .dapi.commands.Move move = 1; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.move_), _Internal::kOneofCaseOffset + 0, 0, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.Talk talk = 2; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.talk_), _Internal::kOneofCaseOffset + 0, 1, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SelectStoreOption option = 3; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.option_), _Internal::kOneofCaseOffset + 0, 2, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.BuyItem buyItem = 4; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.buyitem_), _Internal::kOneofCaseOffset + 0, 3, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SellItem sellItem = 5; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.sellitem_), _Internal::kOneofCaseOffset + 0, 4, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.RechargeItem rechargeItem = 6; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.rechargeitem_), _Internal::kOneofCaseOffset + 0, 5, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.RepairItem repairItem = 7; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.repairitem_), _Internal::kOneofCaseOffset + 0, 6, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.AttackMonster attackMonster = 8; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.attackmonster_), _Internal::kOneofCaseOffset + 0, 7, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.AttackXY attackXY = 9; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.attackxy_), _Internal::kOneofCaseOffset + 0, 8, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.OperateObject operateObject = 10; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.operateobject_), _Internal::kOneofCaseOffset + 0, 9, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.UseBeltItem useBeltItem = 11; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.usebeltitem_), _Internal::kOneofCaseOffset + 0, 10, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.togglecharactersheet_), _Internal::kOneofCaseOffset + 0, 11, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.IncreaseStat increaseStat = 13; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.increasestat_), _Internal::kOneofCaseOffset + 0, 12, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.GetItem getItem = 14; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.getitem_), _Internal::kOneofCaseOffset + 0, 13, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SetSpell setSpell = 15; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.setspell_), _Internal::kOneofCaseOffset + 0, 14, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.CastMonster castMonster = 16; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.castmonster_), _Internal::kOneofCaseOffset + 0, 15, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.CastXY castXY = 17; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.castxy_), _Internal::kOneofCaseOffset + 0, 16, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.ToggleInventory toggleInventory = 18; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.toggleinventory_), _Internal::kOneofCaseOffset + 0, 17, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.PutInCursor putInCursor = 19; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.putincursor_), _Internal::kOneofCaseOffset + 0, 18, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.PutCursorItem putCursorItem = 20; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.putcursoritem_), _Internal::kOneofCaseOffset + 0, 19, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.DropCursorItem dropCursorItem = 21; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.dropcursoritem_), _Internal::kOneofCaseOffset + 0, 20, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.UseItem useItem = 22; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.useitem_), _Internal::kOneofCaseOffset + 0, 21, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.identifystoreitem_), _Internal::kOneofCaseOffset + 0, 22, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.CancelQText cancelQText = 24; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.cancelqtext_), _Internal::kOneofCaseOffset + 0, 23, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SetFPS setFPS = 25; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.setfps_), _Internal::kOneofCaseOffset + 0, 24, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.DisarmTrap disarmTrap = 26; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.disarmtrap_), _Internal::kOneofCaseOffset + 0, 25, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SkillRepair skillRepair = 27; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.skillrepair_), _Internal::kOneofCaseOffset + 0, 26, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SkillRecharge skillRecharge = 28; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.skillrecharge_), _Internal::kOneofCaseOffset + 0, 27, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.ToggleMenu toggleMenu = 29; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.togglemenu_), _Internal::kOneofCaseOffset + 0, 28, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.SaveGame saveGame = 30; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.savegame_), _Internal::kOneofCaseOffset + 0, 29, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.Quit quit = 31; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.quit_), _Internal::kOneofCaseOffset + 0, 30, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.ClearCursor clearCursor = 32; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.clearcursor_), _Internal::kOneofCaseOffset + 0, 31, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.IdentifyItem identifyItem = 33; - {PROTOBUF_FIELD_OFFSET(Command, _impl_.command_.identifyitem_), _Internal::kOneofCaseOffset + 0, 32, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, {{ - {::_pbi::TcParser::GetTable<::dapi::commands::Move>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::Talk>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SelectStoreOption>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::BuyItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SellItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::RechargeItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::RepairItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::AttackMonster>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::AttackXY>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::OperateObject>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::UseBeltItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::ToggleCharacterSheet>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::IncreaseStat>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::GetItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SetSpell>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::CastMonster>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::CastXY>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::ToggleInventory>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::PutInCursor>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::PutCursorItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::DropCursorItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::UseItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::IdentifyStoreItem>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::CancelQText>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SetFPS>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::DisarmTrap>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SkillRepair>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SkillRecharge>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::ToggleMenu>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::SaveGame>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::Quit>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::ClearCursor>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::IdentifyItem>()}, - }}, {{ - }}, -}; - -PROTOBUF_NOINLINE void Command::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.commands.Command) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_command(); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* Command::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const Command& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* Command::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const Command& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.commands.Command) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - switch (this_.command_case()) { - case kMove: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 1, *this_._impl_.command_.move_, this_._impl_.command_.move_->GetCachedSize(), target, - stream); - break; - } - case kTalk: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.command_.talk_, this_._impl_.command_.talk_->GetCachedSize(), target, - stream); - break; - } - case kOption: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, *this_._impl_.command_.option_, this_._impl_.command_.option_->GetCachedSize(), target, - stream); - break; - } - case kBuyItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 4, *this_._impl_.command_.buyitem_, this_._impl_.command_.buyitem_->GetCachedSize(), target, - stream); - break; - } - case kSellItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 5, *this_._impl_.command_.sellitem_, this_._impl_.command_.sellitem_->GetCachedSize(), target, - stream); - break; - } - case kRechargeItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 6, *this_._impl_.command_.rechargeitem_, this_._impl_.command_.rechargeitem_->GetCachedSize(), target, - stream); - break; - } - case kRepairItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 7, *this_._impl_.command_.repairitem_, this_._impl_.command_.repairitem_->GetCachedSize(), target, - stream); - break; - } - case kAttackMonster: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 8, *this_._impl_.command_.attackmonster_, this_._impl_.command_.attackmonster_->GetCachedSize(), target, - stream); - break; - } - case kAttackXY: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 9, *this_._impl_.command_.attackxy_, this_._impl_.command_.attackxy_->GetCachedSize(), target, - stream); - break; - } - case kOperateObject: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 10, *this_._impl_.command_.operateobject_, this_._impl_.command_.operateobject_->GetCachedSize(), target, - stream); - break; - } - case kUseBeltItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 11, *this_._impl_.command_.usebeltitem_, this_._impl_.command_.usebeltitem_->GetCachedSize(), target, - stream); - break; - } - case kToggleCharacterSheet: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 12, *this_._impl_.command_.togglecharactersheet_, this_._impl_.command_.togglecharactersheet_->GetCachedSize(), target, - stream); - break; - } - case kIncreaseStat: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 13, *this_._impl_.command_.increasestat_, this_._impl_.command_.increasestat_->GetCachedSize(), target, - stream); - break; - } - case kGetItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 14, *this_._impl_.command_.getitem_, this_._impl_.command_.getitem_->GetCachedSize(), target, - stream); - break; - } - case kSetSpell: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 15, *this_._impl_.command_.setspell_, this_._impl_.command_.setspell_->GetCachedSize(), target, - stream); - break; - } - case kCastMonster: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 16, *this_._impl_.command_.castmonster_, this_._impl_.command_.castmonster_->GetCachedSize(), target, - stream); - break; - } - case kCastXY: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 17, *this_._impl_.command_.castxy_, this_._impl_.command_.castxy_->GetCachedSize(), target, - stream); - break; - } - case kToggleInventory: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 18, *this_._impl_.command_.toggleinventory_, this_._impl_.command_.toggleinventory_->GetCachedSize(), target, - stream); - break; - } - case kPutInCursor: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 19, *this_._impl_.command_.putincursor_, this_._impl_.command_.putincursor_->GetCachedSize(), target, - stream); - break; - } - case kPutCursorItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 20, *this_._impl_.command_.putcursoritem_, this_._impl_.command_.putcursoritem_->GetCachedSize(), target, - stream); - break; - } - case kDropCursorItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 21, *this_._impl_.command_.dropcursoritem_, this_._impl_.command_.dropcursoritem_->GetCachedSize(), target, - stream); - break; - } - case kUseItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 22, *this_._impl_.command_.useitem_, this_._impl_.command_.useitem_->GetCachedSize(), target, - stream); - break; - } - case kIdentifyStoreItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 23, *this_._impl_.command_.identifystoreitem_, this_._impl_.command_.identifystoreitem_->GetCachedSize(), target, - stream); - break; - } - case kCancelQText: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 24, *this_._impl_.command_.cancelqtext_, this_._impl_.command_.cancelqtext_->GetCachedSize(), target, - stream); - break; - } - case kSetFPS: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 25, *this_._impl_.command_.setfps_, this_._impl_.command_.setfps_->GetCachedSize(), target, - stream); - break; - } - case kDisarmTrap: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 26, *this_._impl_.command_.disarmtrap_, this_._impl_.command_.disarmtrap_->GetCachedSize(), target, - stream); - break; - } - case kSkillRepair: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 27, *this_._impl_.command_.skillrepair_, this_._impl_.command_.skillrepair_->GetCachedSize(), target, - stream); - break; - } - case kSkillRecharge: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 28, *this_._impl_.command_.skillrecharge_, this_._impl_.command_.skillrecharge_->GetCachedSize(), target, - stream); - break; - } - case kToggleMenu: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 29, *this_._impl_.command_.togglemenu_, this_._impl_.command_.togglemenu_->GetCachedSize(), target, - stream); - break; - } - case kSaveGame: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 30, *this_._impl_.command_.savegame_, this_._impl_.command_.savegame_->GetCachedSize(), target, - stream); - break; - } - case kQuit: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 31, *this_._impl_.command_.quit_, this_._impl_.command_.quit_->GetCachedSize(), target, - stream); - break; - } - case kClearCursor: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 32, *this_._impl_.command_.clearcursor_, this_._impl_.command_.clearcursor_->GetCachedSize(), target, - stream); - break; - } - case kIdentifyItem: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 33, *this_._impl_.command_.identifyitem_, this_._impl_.command_.identifyitem_->GetCachedSize(), target, - stream); - break; - } - default: - break; - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.commands.Command) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t Command::ByteSizeLong(const MessageLite& base) { - const Command& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t Command::ByteSizeLong() const { - const Command& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.commands.Command) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - switch (this_.command_case()) { - // .dapi.commands.Move move = 1; - case kMove: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.move_); - break; - } - // .dapi.commands.Talk talk = 2; - case kTalk: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.talk_); - break; - } - // .dapi.commands.SelectStoreOption option = 3; - case kOption: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.option_); - break; - } - // .dapi.commands.BuyItem buyItem = 4; - case kBuyItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.buyitem_); - break; - } - // .dapi.commands.SellItem sellItem = 5; - case kSellItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.sellitem_); - break; - } - // .dapi.commands.RechargeItem rechargeItem = 6; - case kRechargeItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.rechargeitem_); - break; - } - // .dapi.commands.RepairItem repairItem = 7; - case kRepairItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.repairitem_); - break; - } - // .dapi.commands.AttackMonster attackMonster = 8; - case kAttackMonster: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.attackmonster_); - break; - } - // .dapi.commands.AttackXY attackXY = 9; - case kAttackXY: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.attackxy_); - break; - } - // .dapi.commands.OperateObject operateObject = 10; - case kOperateObject: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.operateobject_); - break; - } - // .dapi.commands.UseBeltItem useBeltItem = 11; - case kUseBeltItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.usebeltitem_); - break; - } - // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; - case kToggleCharacterSheet: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.togglecharactersheet_); - break; - } - // .dapi.commands.IncreaseStat increaseStat = 13; - case kIncreaseStat: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.increasestat_); - break; - } - // .dapi.commands.GetItem getItem = 14; - case kGetItem: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.getitem_); - break; - } - // .dapi.commands.SetSpell setSpell = 15; - case kSetSpell: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.setspell_); - break; - } - // .dapi.commands.CastMonster castMonster = 16; - case kCastMonster: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.castmonster_); - break; - } - // .dapi.commands.CastXY castXY = 17; - case kCastXY: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.castxy_); - break; - } - // .dapi.commands.ToggleInventory toggleInventory = 18; - case kToggleInventory: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.toggleinventory_); - break; - } - // .dapi.commands.PutInCursor putInCursor = 19; - case kPutInCursor: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.putincursor_); - break; - } - // .dapi.commands.PutCursorItem putCursorItem = 20; - case kPutCursorItem: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.putcursoritem_); - break; - } - // .dapi.commands.DropCursorItem dropCursorItem = 21; - case kDropCursorItem: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.dropcursoritem_); - break; - } - // .dapi.commands.UseItem useItem = 22; - case kUseItem: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.useitem_); - break; - } - // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; - case kIdentifyStoreItem: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.identifystoreitem_); - break; - } - // .dapi.commands.CancelQText cancelQText = 24; - case kCancelQText: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.cancelqtext_); - break; - } - // .dapi.commands.SetFPS setFPS = 25; - case kSetFPS: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.setfps_); - break; - } - // .dapi.commands.DisarmTrap disarmTrap = 26; - case kDisarmTrap: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.disarmtrap_); - break; - } - // .dapi.commands.SkillRepair skillRepair = 27; - case kSkillRepair: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.skillrepair_); - break; - } - // .dapi.commands.SkillRecharge skillRecharge = 28; - case kSkillRecharge: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.skillrecharge_); - break; - } - // .dapi.commands.ToggleMenu toggleMenu = 29; - case kToggleMenu: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.togglemenu_); - break; - } - // .dapi.commands.SaveGame saveGame = 30; - case kSaveGame: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.savegame_); - break; - } - // .dapi.commands.Quit quit = 31; - case kQuit: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.quit_); - break; - } - // .dapi.commands.ClearCursor clearCursor = 32; - case kClearCursor: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.clearcursor_); - break; - } - // .dapi.commands.IdentifyItem identifyItem = 33; - case kIdentifyItem: { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.command_.identifyitem_); - break; - } - case COMMAND_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void Command::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.commands.Command) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { - const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; - const bool oneof_needs_init = oneof_to_case != oneof_from_case; - if (oneof_needs_init) { - if (oneof_to_case != 0) { - _this->clear_command(); - } - _this->_impl_._oneof_case_[0] = oneof_from_case; - } - - switch (oneof_from_case) { - case kMove: { - if (oneof_needs_init) { - _this->_impl_.command_.move_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Move>(arena, *from._impl_.command_.move_); - } else { - _this->_impl_.command_.move_->MergeFrom(from._internal_move()); - } - break; - } - case kTalk: { - if (oneof_needs_init) { - _this->_impl_.command_.talk_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Talk>(arena, *from._impl_.command_.talk_); - } else { - _this->_impl_.command_.talk_->MergeFrom(from._internal_talk()); - } - break; - } - case kOption: { - if (oneof_needs_init) { - _this->_impl_.command_.option_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SelectStoreOption>(arena, *from._impl_.command_.option_); - } else { - _this->_impl_.command_.option_->MergeFrom(from._internal_option()); - } - break; - } - case kBuyItem: { - if (oneof_needs_init) { - _this->_impl_.command_.buyitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::BuyItem>(arena, *from._impl_.command_.buyitem_); - } else { - _this->_impl_.command_.buyitem_->MergeFrom(from._internal_buyitem()); - } - break; - } - case kSellItem: { - if (oneof_needs_init) { - _this->_impl_.command_.sellitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SellItem>(arena, *from._impl_.command_.sellitem_); - } else { - _this->_impl_.command_.sellitem_->MergeFrom(from._internal_sellitem()); - } - break; - } - case kRechargeItem: { - if (oneof_needs_init) { - _this->_impl_.command_.rechargeitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RechargeItem>(arena, *from._impl_.command_.rechargeitem_); - } else { - _this->_impl_.command_.rechargeitem_->MergeFrom(from._internal_rechargeitem()); - } - break; - } - case kRepairItem: { - if (oneof_needs_init) { - _this->_impl_.command_.repairitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::RepairItem>(arena, *from._impl_.command_.repairitem_); - } else { - _this->_impl_.command_.repairitem_->MergeFrom(from._internal_repairitem()); - } - break; - } - case kAttackMonster: { - if (oneof_needs_init) { - _this->_impl_.command_.attackmonster_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackMonster>(arena, *from._impl_.command_.attackmonster_); - } else { - _this->_impl_.command_.attackmonster_->MergeFrom(from._internal_attackmonster()); - } - break; - } - case kAttackXY: { - if (oneof_needs_init) { - _this->_impl_.command_.attackxy_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::AttackXY>(arena, *from._impl_.command_.attackxy_); - } else { - _this->_impl_.command_.attackxy_->MergeFrom(from._internal_attackxy()); - } - break; - } - case kOperateObject: { - if (oneof_needs_init) { - _this->_impl_.command_.operateobject_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::OperateObject>(arena, *from._impl_.command_.operateobject_); - } else { - _this->_impl_.command_.operateobject_->MergeFrom(from._internal_operateobject()); - } - break; - } - case kUseBeltItem: { - if (oneof_needs_init) { - _this->_impl_.command_.usebeltitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseBeltItem>(arena, *from._impl_.command_.usebeltitem_); - } else { - _this->_impl_.command_.usebeltitem_->MergeFrom(from._internal_usebeltitem()); - } - break; - } - case kToggleCharacterSheet: { - if (oneof_needs_init) { - _this->_impl_.command_.togglecharactersheet_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleCharacterSheet>(arena, *from._impl_.command_.togglecharactersheet_); - } else { - _this->_impl_.command_.togglecharactersheet_->MergeFrom(from._internal_togglecharactersheet()); - } - break; - } - case kIncreaseStat: { - if (oneof_needs_init) { - _this->_impl_.command_.increasestat_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IncreaseStat>(arena, *from._impl_.command_.increasestat_); - } else { - _this->_impl_.command_.increasestat_->MergeFrom(from._internal_increasestat()); - } - break; - } - case kGetItem: { - if (oneof_needs_init) { - _this->_impl_.command_.getitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::GetItem>(arena, *from._impl_.command_.getitem_); - } else { - _this->_impl_.command_.getitem_->MergeFrom(from._internal_getitem()); - } - break; - } - case kSetSpell: { - if (oneof_needs_init) { - _this->_impl_.command_.setspell_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetSpell>(arena, *from._impl_.command_.setspell_); - } else { - _this->_impl_.command_.setspell_->MergeFrom(from._internal_setspell()); - } - break; - } - case kCastMonster: { - if (oneof_needs_init) { - _this->_impl_.command_.castmonster_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastMonster>(arena, *from._impl_.command_.castmonster_); - } else { - _this->_impl_.command_.castmonster_->MergeFrom(from._internal_castmonster()); - } - break; - } - case kCastXY: { - if (oneof_needs_init) { - _this->_impl_.command_.castxy_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CastXY>(arena, *from._impl_.command_.castxy_); - } else { - _this->_impl_.command_.castxy_->MergeFrom(from._internal_castxy()); - } - break; - } - case kToggleInventory: { - if (oneof_needs_init) { - _this->_impl_.command_.toggleinventory_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleInventory>(arena, *from._impl_.command_.toggleinventory_); - } else { - _this->_impl_.command_.toggleinventory_->MergeFrom(from._internal_toggleinventory()); - } - break; - } - case kPutInCursor: { - if (oneof_needs_init) { - _this->_impl_.command_.putincursor_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutInCursor>(arena, *from._impl_.command_.putincursor_); - } else { - _this->_impl_.command_.putincursor_->MergeFrom(from._internal_putincursor()); - } - break; - } - case kPutCursorItem: { - if (oneof_needs_init) { - _this->_impl_.command_.putcursoritem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::PutCursorItem>(arena, *from._impl_.command_.putcursoritem_); - } else { - _this->_impl_.command_.putcursoritem_->MergeFrom(from._internal_putcursoritem()); - } - break; - } - case kDropCursorItem: { - if (oneof_needs_init) { - _this->_impl_.command_.dropcursoritem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DropCursorItem>(arena, *from._impl_.command_.dropcursoritem_); - } else { - _this->_impl_.command_.dropcursoritem_->MergeFrom(from._internal_dropcursoritem()); - } - break; - } - case kUseItem: { - if (oneof_needs_init) { - _this->_impl_.command_.useitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::UseItem>(arena, *from._impl_.command_.useitem_); - } else { - _this->_impl_.command_.useitem_->MergeFrom(from._internal_useitem()); - } - break; - } - case kIdentifyStoreItem: { - if (oneof_needs_init) { - _this->_impl_.command_.identifystoreitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyStoreItem>(arena, *from._impl_.command_.identifystoreitem_); - } else { - _this->_impl_.command_.identifystoreitem_->MergeFrom(from._internal_identifystoreitem()); - } - break; - } - case kCancelQText: { - if (oneof_needs_init) { - _this->_impl_.command_.cancelqtext_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::CancelQText>(arena, *from._impl_.command_.cancelqtext_); - } else { - _this->_impl_.command_.cancelqtext_->MergeFrom(from._internal_cancelqtext()); - } - break; - } - case kSetFPS: { - if (oneof_needs_init) { - _this->_impl_.command_.setfps_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SetFPS>(arena, *from._impl_.command_.setfps_); - } else { - _this->_impl_.command_.setfps_->MergeFrom(from._internal_setfps()); - } - break; - } - case kDisarmTrap: { - if (oneof_needs_init) { - _this->_impl_.command_.disarmtrap_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::DisarmTrap>(arena, *from._impl_.command_.disarmtrap_); - } else { - _this->_impl_.command_.disarmtrap_->MergeFrom(from._internal_disarmtrap()); - } - break; - } - case kSkillRepair: { - if (oneof_needs_init) { - _this->_impl_.command_.skillrepair_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRepair>(arena, *from._impl_.command_.skillrepair_); - } else { - _this->_impl_.command_.skillrepair_->MergeFrom(from._internal_skillrepair()); - } - break; - } - case kSkillRecharge: { - if (oneof_needs_init) { - _this->_impl_.command_.skillrecharge_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SkillRecharge>(arena, *from._impl_.command_.skillrecharge_); - } else { - _this->_impl_.command_.skillrecharge_->MergeFrom(from._internal_skillrecharge()); - } - break; - } - case kToggleMenu: { - if (oneof_needs_init) { - _this->_impl_.command_.togglemenu_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ToggleMenu>(arena, *from._impl_.command_.togglemenu_); - } else { - _this->_impl_.command_.togglemenu_->MergeFrom(from._internal_togglemenu()); - } - break; - } - case kSaveGame: { - if (oneof_needs_init) { - _this->_impl_.command_.savegame_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::SaveGame>(arena, *from._impl_.command_.savegame_); - } else { - _this->_impl_.command_.savegame_->MergeFrom(from._internal_savegame()); - } - break; - } - case kQuit: { - if (oneof_needs_init) { - _this->_impl_.command_.quit_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Quit>(arena, *from._impl_.command_.quit_); - } else { - _this->_impl_.command_.quit_->MergeFrom(from._internal_quit()); - } - break; - } - case kClearCursor: { - if (oneof_needs_init) { - _this->_impl_.command_.clearcursor_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::ClearCursor>(arena, *from._impl_.command_.clearcursor_); - } else { - _this->_impl_.command_.clearcursor_->MergeFrom(from._internal_clearcursor()); - } - break; - } - case kIdentifyItem: { - if (oneof_needs_init) { - _this->_impl_.command_.identifyitem_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::IdentifyItem>(arena, *from._impl_.command_.identifyitem_); - } else { - _this->_impl_.command_.identifyitem_->MergeFrom(from._internal_identifyitem()); - } - break; - } - case COMMAND_NOT_SET: - break; - } - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void Command::CopyFrom(const Command& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.commands.Command) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void Command::InternalSwap(Command* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.command_, other->_impl_.command_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace commands -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google -// @@protoc_insertion_point(global_scope) -#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/command.pb.h b/Source/dapi/Backend/Messages/generated/command.pb.h deleted file mode 100644 index 9038fe269..000000000 --- a/Source/dapi/Backend/Messages/generated/command.pb.h +++ /dev/null @@ -1,10429 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: command.proto -// Protobuf C++ Version: 5.29.3 - -#ifndef command_2eproto_2epb_2eh -#define command_2eproto_2epb_2eh - -#include -#include -#include -#include - -#include "google/protobuf/runtime_version.h" -#if PROTOBUF_VERSION != 5029003 -#error "Protobuf C++ gencode is built with an incompatible version of" -#error "Protobuf C++ headers/runtime. See" -#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" -#endif -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/arena.h" -#include "google/protobuf/arenastring.h" -#include "google/protobuf/generated_message_tctable_decl.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/metadata_lite.h" -#include "google/protobuf/message_lite.h" -#include "google/protobuf/repeated_field.h" // IWYU pragma: export -#include "google/protobuf/extension_set.h" // IWYU pragma: export -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" - -#define PROTOBUF_INTERNAL_EXPORT_command_2eproto - -namespace google { -namespace protobuf { -namespace internal { -template -::absl::string_view GetAnyMessageName(); -} // namespace internal -} // namespace protobuf -} // namespace google - -// Internal implementation detail -- do not use these members. -struct TableStruct_command_2eproto { - static const ::uint32_t offsets[]; -}; -namespace dapi { -namespace commands { -class AttackMonster; -struct AttackMonsterDefaultTypeInternal; -extern AttackMonsterDefaultTypeInternal _AttackMonster_default_instance_; -class AttackXY; -struct AttackXYDefaultTypeInternal; -extern AttackXYDefaultTypeInternal _AttackXY_default_instance_; -class BuyItem; -struct BuyItemDefaultTypeInternal; -extern BuyItemDefaultTypeInternal _BuyItem_default_instance_; -class CancelQText; -struct CancelQTextDefaultTypeInternal; -extern CancelQTextDefaultTypeInternal _CancelQText_default_instance_; -class CastMonster; -struct CastMonsterDefaultTypeInternal; -extern CastMonsterDefaultTypeInternal _CastMonster_default_instance_; -class CastXY; -struct CastXYDefaultTypeInternal; -extern CastXYDefaultTypeInternal _CastXY_default_instance_; -class ClearCursor; -struct ClearCursorDefaultTypeInternal; -extern ClearCursorDefaultTypeInternal _ClearCursor_default_instance_; -class Command; -struct CommandDefaultTypeInternal; -extern CommandDefaultTypeInternal _Command_default_instance_; -class DisarmTrap; -struct DisarmTrapDefaultTypeInternal; -extern DisarmTrapDefaultTypeInternal _DisarmTrap_default_instance_; -class DropCursorItem; -struct DropCursorItemDefaultTypeInternal; -extern DropCursorItemDefaultTypeInternal _DropCursorItem_default_instance_; -class GetItem; -struct GetItemDefaultTypeInternal; -extern GetItemDefaultTypeInternal _GetItem_default_instance_; -class IdentifyItem; -struct IdentifyItemDefaultTypeInternal; -extern IdentifyItemDefaultTypeInternal _IdentifyItem_default_instance_; -class IdentifyStoreItem; -struct IdentifyStoreItemDefaultTypeInternal; -extern IdentifyStoreItemDefaultTypeInternal _IdentifyStoreItem_default_instance_; -class IncreaseStat; -struct IncreaseStatDefaultTypeInternal; -extern IncreaseStatDefaultTypeInternal _IncreaseStat_default_instance_; -class Move; -struct MoveDefaultTypeInternal; -extern MoveDefaultTypeInternal _Move_default_instance_; -class OperateObject; -struct OperateObjectDefaultTypeInternal; -extern OperateObjectDefaultTypeInternal _OperateObject_default_instance_; -class PutCursorItem; -struct PutCursorItemDefaultTypeInternal; -extern PutCursorItemDefaultTypeInternal _PutCursorItem_default_instance_; -class PutInCursor; -struct PutInCursorDefaultTypeInternal; -extern PutInCursorDefaultTypeInternal _PutInCursor_default_instance_; -class Quit; -struct QuitDefaultTypeInternal; -extern QuitDefaultTypeInternal _Quit_default_instance_; -class RechargeItem; -struct RechargeItemDefaultTypeInternal; -extern RechargeItemDefaultTypeInternal _RechargeItem_default_instance_; -class RepairItem; -struct RepairItemDefaultTypeInternal; -extern RepairItemDefaultTypeInternal _RepairItem_default_instance_; -class SaveGame; -struct SaveGameDefaultTypeInternal; -extern SaveGameDefaultTypeInternal _SaveGame_default_instance_; -class SelectStoreOption; -struct SelectStoreOptionDefaultTypeInternal; -extern SelectStoreOptionDefaultTypeInternal _SelectStoreOption_default_instance_; -class SellItem; -struct SellItemDefaultTypeInternal; -extern SellItemDefaultTypeInternal _SellItem_default_instance_; -class SetFPS; -struct SetFPSDefaultTypeInternal; -extern SetFPSDefaultTypeInternal _SetFPS_default_instance_; -class SetSpell; -struct SetSpellDefaultTypeInternal; -extern SetSpellDefaultTypeInternal _SetSpell_default_instance_; -class SkillRecharge; -struct SkillRechargeDefaultTypeInternal; -extern SkillRechargeDefaultTypeInternal _SkillRecharge_default_instance_; -class SkillRepair; -struct SkillRepairDefaultTypeInternal; -extern SkillRepairDefaultTypeInternal _SkillRepair_default_instance_; -class Talk; -struct TalkDefaultTypeInternal; -extern TalkDefaultTypeInternal _Talk_default_instance_; -class ToggleCharacterSheet; -struct ToggleCharacterSheetDefaultTypeInternal; -extern ToggleCharacterSheetDefaultTypeInternal _ToggleCharacterSheet_default_instance_; -class ToggleInventory; -struct ToggleInventoryDefaultTypeInternal; -extern ToggleInventoryDefaultTypeInternal _ToggleInventory_default_instance_; -class ToggleMenu; -struct ToggleMenuDefaultTypeInternal; -extern ToggleMenuDefaultTypeInternal _ToggleMenu_default_instance_; -class UseBeltItem; -struct UseBeltItemDefaultTypeInternal; -extern UseBeltItemDefaultTypeInternal _UseBeltItem_default_instance_; -class UseItem; -struct UseItemDefaultTypeInternal; -extern UseItemDefaultTypeInternal _UseItem_default_instance_; -} // namespace commands -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google - -namespace dapi { -namespace commands { - -// =================================================================== - - -// ------------------------------------------------------------------- - -class UseItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.UseItem) */ { - public: - inline UseItem() : UseItem(nullptr) {} - ~UseItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(UseItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(UseItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR UseItem( - ::google::protobuf::internal::ConstantInitialized); - - inline UseItem(const UseItem& from) : UseItem(nullptr, from) {} - inline UseItem(UseItem&& from) noexcept - : UseItem(nullptr, std::move(from)) {} - inline UseItem& operator=(const UseItem& from) { - CopyFrom(from); - return *this; - } - inline UseItem& operator=(UseItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const UseItem& default_instance() { - return *internal_default_instance(); - } - static inline const UseItem* internal_default_instance() { - return reinterpret_cast( - &_UseItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 23; - friend void swap(UseItem& a, UseItem& b) { a.Swap(&b); } - inline void Swap(UseItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(UseItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - UseItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const UseItem& from); - void MergeFrom(const UseItem& from) { UseItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(UseItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.UseItem"; } - - protected: - explicit UseItem(::google::protobuf::Arena* arena); - UseItem(::google::protobuf::Arena* arena, const UseItem& from); - UseItem(::google::protobuf::Arena* arena, UseItem&& from) noexcept - : UseItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.UseItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const UseItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class UseBeltItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.UseBeltItem) */ { - public: - inline UseBeltItem() : UseBeltItem(nullptr) {} - ~UseBeltItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(UseBeltItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(UseBeltItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR UseBeltItem( - ::google::protobuf::internal::ConstantInitialized); - - inline UseBeltItem(const UseBeltItem& from) : UseBeltItem(nullptr, from) {} - inline UseBeltItem(UseBeltItem&& from) noexcept - : UseBeltItem(nullptr, std::move(from)) {} - inline UseBeltItem& operator=(const UseBeltItem& from) { - CopyFrom(from); - return *this; - } - inline UseBeltItem& operator=(UseBeltItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const UseBeltItem& default_instance() { - return *internal_default_instance(); - } - static inline const UseBeltItem* internal_default_instance() { - return reinterpret_cast( - &_UseBeltItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 12; - friend void swap(UseBeltItem& a, UseBeltItem& b) { a.Swap(&b); } - inline void Swap(UseBeltItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(UseBeltItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - UseBeltItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const UseBeltItem& from); - void MergeFrom(const UseBeltItem& from) { UseBeltItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(UseBeltItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.UseBeltItem"; } - - protected: - explicit UseBeltItem(::google::protobuf::Arena* arena); - UseBeltItem(::google::protobuf::Arena* arena, const UseBeltItem& from); - UseBeltItem(::google::protobuf::Arena* arena, UseBeltItem&& from) noexcept - : UseBeltItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kSlotFieldNumber = 1, - }; - // uint32 slot = 1; - void clear_slot() ; - ::uint32_t slot() const; - void set_slot(::uint32_t value); - - private: - ::uint32_t _internal_slot() const; - void _internal_set_slot(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.UseBeltItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const UseBeltItem& from_msg); - ::uint32_t slot_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class ToggleMenu final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleMenu) */ { - public: - inline ToggleMenu() : ToggleMenu(nullptr) {} - ~ToggleMenu() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ToggleMenu* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleMenu)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ToggleMenu( - ::google::protobuf::internal::ConstantInitialized); - - inline ToggleMenu(const ToggleMenu& from) : ToggleMenu(nullptr, from) {} - inline ToggleMenu(ToggleMenu&& from) noexcept - : ToggleMenu(nullptr, std::move(from)) {} - inline ToggleMenu& operator=(const ToggleMenu& from) { - CopyFrom(from); - return *this; - } - inline ToggleMenu& operator=(ToggleMenu&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ToggleMenu& default_instance() { - return *internal_default_instance(); - } - static inline const ToggleMenu* internal_default_instance() { - return reinterpret_cast( - &_ToggleMenu_default_instance_); - } - static constexpr int kIndexInFileMessages = 28; - friend void swap(ToggleMenu& a, ToggleMenu& b) { a.Swap(&b); } - inline void Swap(ToggleMenu* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ToggleMenu* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ToggleMenu* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ToggleMenu& from); - void MergeFrom(const ToggleMenu& from) { ToggleMenu::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ToggleMenu* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleMenu"; } - - protected: - explicit ToggleMenu(::google::protobuf::Arena* arena); - ToggleMenu(::google::protobuf::Arena* arena, const ToggleMenu& from); - ToggleMenu(::google::protobuf::Arena* arena, ToggleMenu&& from) noexcept - : ToggleMenu(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.ToggleMenu) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ToggleMenu& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class ToggleInventory final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleInventory) */ { - public: - inline ToggleInventory() : ToggleInventory(nullptr) {} - ~ToggleInventory() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ToggleInventory* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleInventory)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ToggleInventory( - ::google::protobuf::internal::ConstantInitialized); - - inline ToggleInventory(const ToggleInventory& from) : ToggleInventory(nullptr, from) {} - inline ToggleInventory(ToggleInventory&& from) noexcept - : ToggleInventory(nullptr, std::move(from)) {} - inline ToggleInventory& operator=(const ToggleInventory& from) { - CopyFrom(from); - return *this; - } - inline ToggleInventory& operator=(ToggleInventory&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ToggleInventory& default_instance() { - return *internal_default_instance(); - } - static inline const ToggleInventory* internal_default_instance() { - return reinterpret_cast( - &_ToggleInventory_default_instance_); - } - static constexpr int kIndexInFileMessages = 19; - friend void swap(ToggleInventory& a, ToggleInventory& b) { a.Swap(&b); } - inline void Swap(ToggleInventory* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ToggleInventory* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ToggleInventory* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ToggleInventory& from); - void MergeFrom(const ToggleInventory& from) { ToggleInventory::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ToggleInventory* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleInventory"; } - - protected: - explicit ToggleInventory(::google::protobuf::Arena* arena); - ToggleInventory(::google::protobuf::Arena* arena, const ToggleInventory& from); - ToggleInventory(::google::protobuf::Arena* arena, ToggleInventory&& from) noexcept - : ToggleInventory(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<30> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.ToggleInventory) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ToggleInventory& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class ToggleCharacterSheet final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.ToggleCharacterSheet) */ { - public: - inline ToggleCharacterSheet() : ToggleCharacterSheet(nullptr) {} - ~ToggleCharacterSheet() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ToggleCharacterSheet* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ToggleCharacterSheet)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ToggleCharacterSheet( - ::google::protobuf::internal::ConstantInitialized); - - inline ToggleCharacterSheet(const ToggleCharacterSheet& from) : ToggleCharacterSheet(nullptr, from) {} - inline ToggleCharacterSheet(ToggleCharacterSheet&& from) noexcept - : ToggleCharacterSheet(nullptr, std::move(from)) {} - inline ToggleCharacterSheet& operator=(const ToggleCharacterSheet& from) { - CopyFrom(from); - return *this; - } - inline ToggleCharacterSheet& operator=(ToggleCharacterSheet&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ToggleCharacterSheet& default_instance() { - return *internal_default_instance(); - } - static inline const ToggleCharacterSheet* internal_default_instance() { - return reinterpret_cast( - &_ToggleCharacterSheet_default_instance_); - } - static constexpr int kIndexInFileMessages = 13; - friend void swap(ToggleCharacterSheet& a, ToggleCharacterSheet& b) { a.Swap(&b); } - inline void Swap(ToggleCharacterSheet* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ToggleCharacterSheet* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ToggleCharacterSheet* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ToggleCharacterSheet& from); - void MergeFrom(const ToggleCharacterSheet& from) { ToggleCharacterSheet::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ToggleCharacterSheet* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.ToggleCharacterSheet"; } - - protected: - explicit ToggleCharacterSheet(::google::protobuf::Arena* arena); - ToggleCharacterSheet(::google::protobuf::Arena* arena, const ToggleCharacterSheet& from); - ToggleCharacterSheet(::google::protobuf::Arena* arena, ToggleCharacterSheet&& from) noexcept - : ToggleCharacterSheet(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<35> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.ToggleCharacterSheet) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ToggleCharacterSheet& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class Talk final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.Talk) */ { - public: - inline Talk() : Talk(nullptr) {} - ~Talk() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Talk* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Talk)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR Talk( - ::google::protobuf::internal::ConstantInitialized); - - inline Talk(const Talk& from) : Talk(nullptr, from) {} - inline Talk(Talk&& from) noexcept - : Talk(nullptr, std::move(from)) {} - inline Talk& operator=(const Talk& from) { - CopyFrom(from); - return *this; - } - inline Talk& operator=(Talk&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const Talk& default_instance() { - return *internal_default_instance(); - } - static inline const Talk* internal_default_instance() { - return reinterpret_cast( - &_Talk_default_instance_); - } - static constexpr int kIndexInFileMessages = 3; - friend void swap(Talk& a, Talk& b) { a.Swap(&b); } - inline void Swap(Talk* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Talk* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Talk* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const Talk& from); - void MergeFrom(const Talk& from) { Talk::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(Talk* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.Talk"; } - - protected: - explicit Talk(::google::protobuf::Arena* arena); - Talk(::google::protobuf::Arena* arena, const Talk& from); - Talk(::google::protobuf::Arena* arena, Talk&& from) noexcept - : Talk(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTargetXFieldNumber = 1, - kTargetYFieldNumber = 2, - }; - // uint32 targetX = 1; - void clear_targetx() ; - ::uint32_t targetx() const; - void set_targetx(::uint32_t value); - - private: - ::uint32_t _internal_targetx() const; - void _internal_set_targetx(::uint32_t value); - - public: - // uint32 targetY = 2; - void clear_targety() ; - ::uint32_t targety() const; - void set_targety(::uint32_t value); - - private: - ::uint32_t _internal_targety() const; - void _internal_set_targety(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.Talk) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 1, 2, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const Talk& from_msg); - ::uint32_t targetx_; - ::uint32_t targety_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SkillRepair final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SkillRepair) */ { - public: - inline SkillRepair() : SkillRepair(nullptr) {} - ~SkillRepair() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SkillRepair* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SkillRepair)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SkillRepair( - ::google::protobuf::internal::ConstantInitialized); - - inline SkillRepair(const SkillRepair& from) : SkillRepair(nullptr, from) {} - inline SkillRepair(SkillRepair&& from) noexcept - : SkillRepair(nullptr, std::move(from)) {} - inline SkillRepair& operator=(const SkillRepair& from) { - CopyFrom(from); - return *this; - } - inline SkillRepair& operator=(SkillRepair&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SkillRepair& default_instance() { - return *internal_default_instance(); - } - static inline const SkillRepair* internal_default_instance() { - return reinterpret_cast( - &_SkillRepair_default_instance_); - } - static constexpr int kIndexInFileMessages = 26; - friend void swap(SkillRepair& a, SkillRepair& b) { a.Swap(&b); } - inline void Swap(SkillRepair* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SkillRepair* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SkillRepair* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SkillRepair& from); - void MergeFrom(const SkillRepair& from) { SkillRepair::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SkillRepair* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SkillRepair"; } - - protected: - explicit SkillRepair(::google::protobuf::Arena* arena); - SkillRepair(::google::protobuf::Arena* arena, const SkillRepair& from); - SkillRepair(::google::protobuf::Arena* arena, SkillRepair&& from) noexcept - : SkillRepair(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.SkillRepair) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SkillRepair& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SkillRecharge final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SkillRecharge) */ { - public: - inline SkillRecharge() : SkillRecharge(nullptr) {} - ~SkillRecharge() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SkillRecharge* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SkillRecharge)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SkillRecharge( - ::google::protobuf::internal::ConstantInitialized); - - inline SkillRecharge(const SkillRecharge& from) : SkillRecharge(nullptr, from) {} - inline SkillRecharge(SkillRecharge&& from) noexcept - : SkillRecharge(nullptr, std::move(from)) {} - inline SkillRecharge& operator=(const SkillRecharge& from) { - CopyFrom(from); - return *this; - } - inline SkillRecharge& operator=(SkillRecharge&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SkillRecharge& default_instance() { - return *internal_default_instance(); - } - static inline const SkillRecharge* internal_default_instance() { - return reinterpret_cast( - &_SkillRecharge_default_instance_); - } - static constexpr int kIndexInFileMessages = 27; - friend void swap(SkillRecharge& a, SkillRecharge& b) { a.Swap(&b); } - inline void Swap(SkillRecharge* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SkillRecharge* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SkillRecharge* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SkillRecharge& from); - void MergeFrom(const SkillRecharge& from) { SkillRecharge::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SkillRecharge* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SkillRecharge"; } - - protected: - explicit SkillRecharge(::google::protobuf::Arena* arena); - SkillRecharge(::google::protobuf::Arena* arena, const SkillRecharge& from); - SkillRecharge(::google::protobuf::Arena* arena, SkillRecharge&& from) noexcept - : SkillRecharge(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.SkillRecharge) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SkillRecharge& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SetSpell final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SetSpell) */ { - public: - inline SetSpell() : SetSpell(nullptr) {} - ~SetSpell() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SetSpell* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SetSpell)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SetSpell( - ::google::protobuf::internal::ConstantInitialized); - - inline SetSpell(const SetSpell& from) : SetSpell(nullptr, from) {} - inline SetSpell(SetSpell&& from) noexcept - : SetSpell(nullptr, std::move(from)) {} - inline SetSpell& operator=(const SetSpell& from) { - CopyFrom(from); - return *this; - } - inline SetSpell& operator=(SetSpell&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SetSpell& default_instance() { - return *internal_default_instance(); - } - static inline const SetSpell* internal_default_instance() { - return reinterpret_cast( - &_SetSpell_default_instance_); - } - static constexpr int kIndexInFileMessages = 16; - friend void swap(SetSpell& a, SetSpell& b) { a.Swap(&b); } - inline void Swap(SetSpell* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SetSpell* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SetSpell* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SetSpell& from); - void MergeFrom(const SetSpell& from) { SetSpell::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SetSpell* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SetSpell"; } - - protected: - explicit SetSpell(::google::protobuf::Arena* arena); - SetSpell(::google::protobuf::Arena* arena, const SetSpell& from); - SetSpell(::google::protobuf::Arena* arena, SetSpell&& from) noexcept - : SetSpell(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kSpellIDFieldNumber = 1, - kSpellTypeFieldNumber = 2, - }; - // sint32 spellID = 1; - void clear_spellid() ; - ::int32_t spellid() const; - void set_spellid(::int32_t value); - - private: - ::int32_t _internal_spellid() const; - void _internal_set_spellid(::int32_t value); - - public: - // sint32 spellType = 2; - void clear_spelltype() ; - ::int32_t spelltype() const; - void set_spelltype(::int32_t value); - - private: - ::int32_t _internal_spelltype() const; - void _internal_set_spelltype(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.SetSpell) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 1, 2, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SetSpell& from_msg); - ::int32_t spellid_; - ::int32_t spelltype_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SetFPS final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SetFPS) */ { - public: - inline SetFPS() : SetFPS(nullptr) {} - ~SetFPS() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SetFPS* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SetFPS)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SetFPS( - ::google::protobuf::internal::ConstantInitialized); - - inline SetFPS(const SetFPS& from) : SetFPS(nullptr, from) {} - inline SetFPS(SetFPS&& from) noexcept - : SetFPS(nullptr, std::move(from)) {} - inline SetFPS& operator=(const SetFPS& from) { - CopyFrom(from); - return *this; - } - inline SetFPS& operator=(SetFPS&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SetFPS& default_instance() { - return *internal_default_instance(); - } - static inline const SetFPS* internal_default_instance() { - return reinterpret_cast( - &_SetFPS_default_instance_); - } - static constexpr int kIndexInFileMessages = 0; - friend void swap(SetFPS& a, SetFPS& b) { a.Swap(&b); } - inline void Swap(SetFPS* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SetFPS* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SetFPS* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SetFPS& from); - void MergeFrom(const SetFPS& from) { SetFPS::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SetFPS* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SetFPS"; } - - protected: - explicit SetFPS(::google::protobuf::Arena* arena); - SetFPS(::google::protobuf::Arena* arena, const SetFPS& from); - SetFPS(::google::protobuf::Arena* arena, SetFPS&& from) noexcept - : SetFPS(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kFPSFieldNumber = 1, - }; - // uint32 FPS = 1; - void clear_fps() ; - ::uint32_t fps() const; - void set_fps(::uint32_t value); - - private: - ::uint32_t _internal_fps() const; - void _internal_set_fps(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.SetFPS) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SetFPS& from_msg); - ::uint32_t fps_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SellItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SellItem) */ { - public: - inline SellItem() : SellItem(nullptr) {} - ~SellItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SellItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SellItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SellItem( - ::google::protobuf::internal::ConstantInitialized); - - inline SellItem(const SellItem& from) : SellItem(nullptr, from) {} - inline SellItem(SellItem&& from) noexcept - : SellItem(nullptr, std::move(from)) {} - inline SellItem& operator=(const SellItem& from) { - CopyFrom(from); - return *this; - } - inline SellItem& operator=(SellItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SellItem& default_instance() { - return *internal_default_instance(); - } - static inline const SellItem* internal_default_instance() { - return reinterpret_cast( - &_SellItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 6; - friend void swap(SellItem& a, SellItem& b) { a.Swap(&b); } - inline void Swap(SellItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SellItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SellItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SellItem& from); - void MergeFrom(const SellItem& from) { SellItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SellItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SellItem"; } - - protected: - explicit SellItem(::google::protobuf::Arena* arena); - SellItem(::google::protobuf::Arena* arena, const SellItem& from); - SellItem(::google::protobuf::Arena* arena, SellItem&& from) noexcept - : SellItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.SellItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SellItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SelectStoreOption final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SelectStoreOption) */ { - public: - inline SelectStoreOption() : SelectStoreOption(nullptr) {} - ~SelectStoreOption() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SelectStoreOption* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SelectStoreOption)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SelectStoreOption( - ::google::protobuf::internal::ConstantInitialized); - - inline SelectStoreOption(const SelectStoreOption& from) : SelectStoreOption(nullptr, from) {} - inline SelectStoreOption(SelectStoreOption&& from) noexcept - : SelectStoreOption(nullptr, std::move(from)) {} - inline SelectStoreOption& operator=(const SelectStoreOption& from) { - CopyFrom(from); - return *this; - } - inline SelectStoreOption& operator=(SelectStoreOption&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SelectStoreOption& default_instance() { - return *internal_default_instance(); - } - static inline const SelectStoreOption* internal_default_instance() { - return reinterpret_cast( - &_SelectStoreOption_default_instance_); - } - static constexpr int kIndexInFileMessages = 4; - friend void swap(SelectStoreOption& a, SelectStoreOption& b) { a.Swap(&b); } - inline void Swap(SelectStoreOption* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SelectStoreOption* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SelectStoreOption* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SelectStoreOption& from); - void MergeFrom(const SelectStoreOption& from) { SelectStoreOption::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SelectStoreOption* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SelectStoreOption"; } - - protected: - explicit SelectStoreOption(::google::protobuf::Arena* arena); - SelectStoreOption(::google::protobuf::Arena* arena, const SelectStoreOption& from); - SelectStoreOption(::google::protobuf::Arena* arena, SelectStoreOption&& from) noexcept - : SelectStoreOption(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<32> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kOptionFieldNumber = 1, - }; - // uint32 option = 1; - void clear_option() ; - ::uint32_t option() const; - void set_option(::uint32_t value); - - private: - ::uint32_t _internal_option() const; - void _internal_set_option(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.SelectStoreOption) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SelectStoreOption& from_msg); - ::uint32_t option_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class SaveGame final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.SaveGame) */ { - public: - inline SaveGame() : SaveGame(nullptr) {} - ~SaveGame() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(SaveGame* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(SaveGame)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR SaveGame( - ::google::protobuf::internal::ConstantInitialized); - - inline SaveGame(const SaveGame& from) : SaveGame(nullptr, from) {} - inline SaveGame(SaveGame&& from) noexcept - : SaveGame(nullptr, std::move(from)) {} - inline SaveGame& operator=(const SaveGame& from) { - CopyFrom(from); - return *this; - } - inline SaveGame& operator=(SaveGame&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const SaveGame& default_instance() { - return *internal_default_instance(); - } - static inline const SaveGame* internal_default_instance() { - return reinterpret_cast( - &_SaveGame_default_instance_); - } - static constexpr int kIndexInFileMessages = 29; - friend void swap(SaveGame& a, SaveGame& b) { a.Swap(&b); } - inline void Swap(SaveGame* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(SaveGame* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - SaveGame* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const SaveGame& from); - void MergeFrom(const SaveGame& from) { SaveGame::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(SaveGame* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.SaveGame"; } - - protected: - explicit SaveGame(::google::protobuf::Arena* arena); - SaveGame(::google::protobuf::Arena* arena, const SaveGame& from); - SaveGame(::google::protobuf::Arena* arena, SaveGame&& from) noexcept - : SaveGame(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.SaveGame) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const SaveGame& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class RepairItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.RepairItem) */ { - public: - inline RepairItem() : RepairItem(nullptr) {} - ~RepairItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(RepairItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(RepairItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR RepairItem( - ::google::protobuf::internal::ConstantInitialized); - - inline RepairItem(const RepairItem& from) : RepairItem(nullptr, from) {} - inline RepairItem(RepairItem&& from) noexcept - : RepairItem(nullptr, std::move(from)) {} - inline RepairItem& operator=(const RepairItem& from) { - CopyFrom(from); - return *this; - } - inline RepairItem& operator=(RepairItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const RepairItem& default_instance() { - return *internal_default_instance(); - } - static inline const RepairItem* internal_default_instance() { - return reinterpret_cast( - &_RepairItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 8; - friend void swap(RepairItem& a, RepairItem& b) { a.Swap(&b); } - inline void Swap(RepairItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(RepairItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RepairItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const RepairItem& from); - void MergeFrom(const RepairItem& from) { RepairItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(RepairItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.RepairItem"; } - - protected: - explicit RepairItem(::google::protobuf::Arena* arena); - RepairItem(::google::protobuf::Arena* arena, const RepairItem& from); - RepairItem(::google::protobuf::Arena* arena, RepairItem&& from) noexcept - : RepairItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.RepairItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const RepairItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class RechargeItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.RechargeItem) */ { - public: - inline RechargeItem() : RechargeItem(nullptr) {} - ~RechargeItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(RechargeItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(RechargeItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR RechargeItem( - ::google::protobuf::internal::ConstantInitialized); - - inline RechargeItem(const RechargeItem& from) : RechargeItem(nullptr, from) {} - inline RechargeItem(RechargeItem&& from) noexcept - : RechargeItem(nullptr, std::move(from)) {} - inline RechargeItem& operator=(const RechargeItem& from) { - CopyFrom(from); - return *this; - } - inline RechargeItem& operator=(RechargeItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const RechargeItem& default_instance() { - return *internal_default_instance(); - } - static inline const RechargeItem* internal_default_instance() { - return reinterpret_cast( - &_RechargeItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 7; - friend void swap(RechargeItem& a, RechargeItem& b) { a.Swap(&b); } - inline void Swap(RechargeItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(RechargeItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - RechargeItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const RechargeItem& from); - void MergeFrom(const RechargeItem& from) { RechargeItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(RechargeItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.RechargeItem"; } - - protected: - explicit RechargeItem(::google::protobuf::Arena* arena); - RechargeItem(::google::protobuf::Arena* arena, const RechargeItem& from); - RechargeItem(::google::protobuf::Arena* arena, RechargeItem&& from) noexcept - : RechargeItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.RechargeItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const RechargeItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class Quit final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.Quit) */ { - public: - inline Quit() : Quit(nullptr) {} - ~Quit() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Quit* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Quit)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR Quit( - ::google::protobuf::internal::ConstantInitialized); - - inline Quit(const Quit& from) : Quit(nullptr, from) {} - inline Quit(Quit&& from) noexcept - : Quit(nullptr, std::move(from)) {} - inline Quit& operator=(const Quit& from) { - CopyFrom(from); - return *this; - } - inline Quit& operator=(Quit&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const Quit& default_instance() { - return *internal_default_instance(); - } - static inline const Quit* internal_default_instance() { - return reinterpret_cast( - &_Quit_default_instance_); - } - static constexpr int kIndexInFileMessages = 30; - friend void swap(Quit& a, Quit& b) { a.Swap(&b); } - inline void Swap(Quit* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Quit* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Quit* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const Quit& from); - void MergeFrom(const Quit& from) { Quit::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(Quit* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.Quit"; } - - protected: - explicit Quit(::google::protobuf::Arena* arena); - Quit(::google::protobuf::Arena* arena, const Quit& from); - Quit(::google::protobuf::Arena* arena, Quit&& from) noexcept - : Quit(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.Quit) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const Quit& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class PutInCursor final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.PutInCursor) */ { - public: - inline PutInCursor() : PutInCursor(nullptr) {} - ~PutInCursor() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PutInCursor* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PutInCursor)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR PutInCursor( - ::google::protobuf::internal::ConstantInitialized); - - inline PutInCursor(const PutInCursor& from) : PutInCursor(nullptr, from) {} - inline PutInCursor(PutInCursor&& from) noexcept - : PutInCursor(nullptr, std::move(from)) {} - inline PutInCursor& operator=(const PutInCursor& from) { - CopyFrom(from); - return *this; - } - inline PutInCursor& operator=(PutInCursor&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const PutInCursor& default_instance() { - return *internal_default_instance(); - } - static inline const PutInCursor* internal_default_instance() { - return reinterpret_cast( - &_PutInCursor_default_instance_); - } - static constexpr int kIndexInFileMessages = 20; - friend void swap(PutInCursor& a, PutInCursor& b) { a.Swap(&b); } - inline void Swap(PutInCursor* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PutInCursor* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PutInCursor* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const PutInCursor& from); - void MergeFrom(const PutInCursor& from) { PutInCursor::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(PutInCursor* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.PutInCursor"; } - - protected: - explicit PutInCursor(::google::protobuf::Arena* arena); - PutInCursor(::google::protobuf::Arena* arena, const PutInCursor& from); - PutInCursor(::google::protobuf::Arena* arena, PutInCursor&& from) noexcept - : PutInCursor(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.PutInCursor) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const PutInCursor& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class PutCursorItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.PutCursorItem) */ { - public: - inline PutCursorItem() : PutCursorItem(nullptr) {} - ~PutCursorItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PutCursorItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PutCursorItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR PutCursorItem( - ::google::protobuf::internal::ConstantInitialized); - - inline PutCursorItem(const PutCursorItem& from) : PutCursorItem(nullptr, from) {} - inline PutCursorItem(PutCursorItem&& from) noexcept - : PutCursorItem(nullptr, std::move(from)) {} - inline PutCursorItem& operator=(const PutCursorItem& from) { - CopyFrom(from); - return *this; - } - inline PutCursorItem& operator=(PutCursorItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const PutCursorItem& default_instance() { - return *internal_default_instance(); - } - static inline const PutCursorItem* internal_default_instance() { - return reinterpret_cast( - &_PutCursorItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 21; - friend void swap(PutCursorItem& a, PutCursorItem& b) { a.Swap(&b); } - inline void Swap(PutCursorItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PutCursorItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PutCursorItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const PutCursorItem& from); - void MergeFrom(const PutCursorItem& from) { PutCursorItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(PutCursorItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.PutCursorItem"; } - - protected: - explicit PutCursorItem(::google::protobuf::Arena* arena); - PutCursorItem(::google::protobuf::Arena* arena, const PutCursorItem& from); - PutCursorItem(::google::protobuf::Arena* arena, PutCursorItem&& from) noexcept - : PutCursorItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTargetFieldNumber = 1, - }; - // sint32 target = 1; - void clear_target() ; - ::int32_t target() const; - void set_target(::int32_t value); - - private: - ::int32_t _internal_target() const; - void _internal_set_target(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.PutCursorItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const PutCursorItem& from_msg); - ::int32_t target_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class OperateObject final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.OperateObject) */ { - public: - inline OperateObject() : OperateObject(nullptr) {} - ~OperateObject() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(OperateObject* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(OperateObject)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR OperateObject( - ::google::protobuf::internal::ConstantInitialized); - - inline OperateObject(const OperateObject& from) : OperateObject(nullptr, from) {} - inline OperateObject(OperateObject&& from) noexcept - : OperateObject(nullptr, std::move(from)) {} - inline OperateObject& operator=(const OperateObject& from) { - CopyFrom(from); - return *this; - } - inline OperateObject& operator=(OperateObject&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const OperateObject& default_instance() { - return *internal_default_instance(); - } - static inline const OperateObject* internal_default_instance() { - return reinterpret_cast( - &_OperateObject_default_instance_); - } - static constexpr int kIndexInFileMessages = 11; - friend void swap(OperateObject& a, OperateObject& b) { a.Swap(&b); } - inline void Swap(OperateObject* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(OperateObject* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - OperateObject* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const OperateObject& from); - void MergeFrom(const OperateObject& from) { OperateObject::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(OperateObject* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.OperateObject"; } - - protected: - explicit OperateObject(::google::protobuf::Arena* arena); - OperateObject(::google::protobuf::Arena* arena, const OperateObject& from); - OperateObject(::google::protobuf::Arena* arena, OperateObject&& from) noexcept - : OperateObject(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIndexFieldNumber = 1, - }; - // uint32 index = 1; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.OperateObject) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const OperateObject& from_msg); - ::uint32_t index_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class Move final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.Move) */ { - public: - inline Move() : Move(nullptr) {} - ~Move() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Move* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Move)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR Move( - ::google::protobuf::internal::ConstantInitialized); - - inline Move(const Move& from) : Move(nullptr, from) {} - inline Move(Move&& from) noexcept - : Move(nullptr, std::move(from)) {} - inline Move& operator=(const Move& from) { - CopyFrom(from); - return *this; - } - inline Move& operator=(Move&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const Move& default_instance() { - return *internal_default_instance(); - } - static inline const Move* internal_default_instance() { - return reinterpret_cast( - &_Move_default_instance_); - } - static constexpr int kIndexInFileMessages = 2; - friend void swap(Move& a, Move& b) { a.Swap(&b); } - inline void Swap(Move* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Move* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Move* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const Move& from); - void MergeFrom(const Move& from) { Move::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(Move* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.Move"; } - - protected: - explicit Move(::google::protobuf::Arena* arena); - Move(::google::protobuf::Arena* arena, const Move& from); - Move(::google::protobuf::Arena* arena, Move&& from) noexcept - : Move(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTypeFieldNumber = 1, - kTargetXFieldNumber = 2, - kTargetYFieldNumber = 3, - }; - // uint32 type = 1; - void clear_type() ; - ::uint32_t type() const; - void set_type(::uint32_t value); - - private: - ::uint32_t _internal_type() const; - void _internal_set_type(::uint32_t value); - - public: - // uint32 targetX = 2; - void clear_targetx() ; - ::uint32_t targetx() const; - void set_targetx(::uint32_t value); - - private: - ::uint32_t _internal_targetx() const; - void _internal_set_targetx(::uint32_t value); - - public: - // uint32 targetY = 3; - void clear_targety() ; - ::uint32_t targety() const; - void set_targety(::uint32_t value); - - private: - ::uint32_t _internal_targety() const; - void _internal_set_targety(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.Move) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 2, 3, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const Move& from_msg); - ::uint32_t type_; - ::uint32_t targetx_; - ::uint32_t targety_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class IncreaseStat final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.IncreaseStat) */ { - public: - inline IncreaseStat() : IncreaseStat(nullptr) {} - ~IncreaseStat() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(IncreaseStat* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(IncreaseStat)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR IncreaseStat( - ::google::protobuf::internal::ConstantInitialized); - - inline IncreaseStat(const IncreaseStat& from) : IncreaseStat(nullptr, from) {} - inline IncreaseStat(IncreaseStat&& from) noexcept - : IncreaseStat(nullptr, std::move(from)) {} - inline IncreaseStat& operator=(const IncreaseStat& from) { - CopyFrom(from); - return *this; - } - inline IncreaseStat& operator=(IncreaseStat&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const IncreaseStat& default_instance() { - return *internal_default_instance(); - } - static inline const IncreaseStat* internal_default_instance() { - return reinterpret_cast( - &_IncreaseStat_default_instance_); - } - static constexpr int kIndexInFileMessages = 14; - friend void swap(IncreaseStat& a, IncreaseStat& b) { a.Swap(&b); } - inline void Swap(IncreaseStat* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(IncreaseStat* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - IncreaseStat* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const IncreaseStat& from); - void MergeFrom(const IncreaseStat& from) { IncreaseStat::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(IncreaseStat* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.IncreaseStat"; } - - protected: - explicit IncreaseStat(::google::protobuf::Arena* arena); - IncreaseStat(::google::protobuf::Arena* arena, const IncreaseStat& from); - IncreaseStat(::google::protobuf::Arena* arena, IncreaseStat&& from) noexcept - : IncreaseStat(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kStatFieldNumber = 1, - }; - // uint32 stat = 1; - void clear_stat() ; - ::uint32_t stat() const; - void set_stat(::uint32_t value); - - private: - ::uint32_t _internal_stat() const; - void _internal_set_stat(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.IncreaseStat) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const IncreaseStat& from_msg); - ::uint32_t stat_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class IdentifyStoreItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.IdentifyStoreItem) */ { - public: - inline IdentifyStoreItem() : IdentifyStoreItem(nullptr) {} - ~IdentifyStoreItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(IdentifyStoreItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(IdentifyStoreItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR IdentifyStoreItem( - ::google::protobuf::internal::ConstantInitialized); - - inline IdentifyStoreItem(const IdentifyStoreItem& from) : IdentifyStoreItem(nullptr, from) {} - inline IdentifyStoreItem(IdentifyStoreItem&& from) noexcept - : IdentifyStoreItem(nullptr, std::move(from)) {} - inline IdentifyStoreItem& operator=(const IdentifyStoreItem& from) { - CopyFrom(from); - return *this; - } - inline IdentifyStoreItem& operator=(IdentifyStoreItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const IdentifyStoreItem& default_instance() { - return *internal_default_instance(); - } - static inline const IdentifyStoreItem* internal_default_instance() { - return reinterpret_cast( - &_IdentifyStoreItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 24; - friend void swap(IdentifyStoreItem& a, IdentifyStoreItem& b) { a.Swap(&b); } - inline void Swap(IdentifyStoreItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(IdentifyStoreItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - IdentifyStoreItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const IdentifyStoreItem& from); - void MergeFrom(const IdentifyStoreItem& from) { IdentifyStoreItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(IdentifyStoreItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.IdentifyStoreItem"; } - - protected: - explicit IdentifyStoreItem(::google::protobuf::Arena* arena); - IdentifyStoreItem(::google::protobuf::Arena* arena, const IdentifyStoreItem& from); - IdentifyStoreItem(::google::protobuf::Arena* arena, IdentifyStoreItem&& from) noexcept - : IdentifyStoreItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<32> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.IdentifyStoreItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const IdentifyStoreItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class IdentifyItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.IdentifyItem) */ { - public: - inline IdentifyItem() : IdentifyItem(nullptr) {} - ~IdentifyItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(IdentifyItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(IdentifyItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR IdentifyItem( - ::google::protobuf::internal::ConstantInitialized); - - inline IdentifyItem(const IdentifyItem& from) : IdentifyItem(nullptr, from) {} - inline IdentifyItem(IdentifyItem&& from) noexcept - : IdentifyItem(nullptr, std::move(from)) {} - inline IdentifyItem& operator=(const IdentifyItem& from) { - CopyFrom(from); - return *this; - } - inline IdentifyItem& operator=(IdentifyItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const IdentifyItem& default_instance() { - return *internal_default_instance(); - } - static inline const IdentifyItem* internal_default_instance() { - return reinterpret_cast( - &_IdentifyItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 32; - friend void swap(IdentifyItem& a, IdentifyItem& b) { a.Swap(&b); } - inline void Swap(IdentifyItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(IdentifyItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - IdentifyItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const IdentifyItem& from); - void MergeFrom(const IdentifyItem& from) { IdentifyItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(IdentifyItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.IdentifyItem"; } - - protected: - explicit IdentifyItem(::google::protobuf::Arena* arena); - IdentifyItem(::google::protobuf::Arena* arena, const IdentifyItem& from); - IdentifyItem(::google::protobuf::Arena* arena, IdentifyItem&& from) noexcept - : IdentifyItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<27> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.IdentifyItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const IdentifyItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class GetItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.GetItem) */ { - public: - inline GetItem() : GetItem(nullptr) {} - ~GetItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(GetItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(GetItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR GetItem( - ::google::protobuf::internal::ConstantInitialized); - - inline GetItem(const GetItem& from) : GetItem(nullptr, from) {} - inline GetItem(GetItem&& from) noexcept - : GetItem(nullptr, std::move(from)) {} - inline GetItem& operator=(const GetItem& from) { - CopyFrom(from); - return *this; - } - inline GetItem& operator=(GetItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const GetItem& default_instance() { - return *internal_default_instance(); - } - static inline const GetItem* internal_default_instance() { - return reinterpret_cast( - &_GetItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 15; - friend void swap(GetItem& a, GetItem& b) { a.Swap(&b); } - inline void Swap(GetItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(GetItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - GetItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const GetItem& from); - void MergeFrom(const GetItem& from) { GetItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(GetItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.GetItem"; } - - protected: - explicit GetItem(::google::protobuf::Arena* arena); - GetItem(::google::protobuf::Arena* arena, const GetItem& from); - GetItem(::google::protobuf::Arena* arena, GetItem&& from) noexcept - : GetItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.GetItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const GetItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class DropCursorItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.DropCursorItem) */ { - public: - inline DropCursorItem() : DropCursorItem(nullptr) {} - ~DropCursorItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(DropCursorItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(DropCursorItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR DropCursorItem( - ::google::protobuf::internal::ConstantInitialized); - - inline DropCursorItem(const DropCursorItem& from) : DropCursorItem(nullptr, from) {} - inline DropCursorItem(DropCursorItem&& from) noexcept - : DropCursorItem(nullptr, std::move(from)) {} - inline DropCursorItem& operator=(const DropCursorItem& from) { - CopyFrom(from); - return *this; - } - inline DropCursorItem& operator=(DropCursorItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const DropCursorItem& default_instance() { - return *internal_default_instance(); - } - static inline const DropCursorItem* internal_default_instance() { - return reinterpret_cast( - &_DropCursorItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 22; - friend void swap(DropCursorItem& a, DropCursorItem& b) { a.Swap(&b); } - inline void Swap(DropCursorItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DropCursorItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DropCursorItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const DropCursorItem& from); - void MergeFrom(const DropCursorItem& from) { DropCursorItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(DropCursorItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.DropCursorItem"; } - - protected: - explicit DropCursorItem(::google::protobuf::Arena* arena); - DropCursorItem(::google::protobuf::Arena* arena, const DropCursorItem& from); - DropCursorItem(::google::protobuf::Arena* arena, DropCursorItem&& from) noexcept - : DropCursorItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<29> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.DropCursorItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const DropCursorItem& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class DisarmTrap final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.DisarmTrap) */ { - public: - inline DisarmTrap() : DisarmTrap(nullptr) {} - ~DisarmTrap() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(DisarmTrap* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(DisarmTrap)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR DisarmTrap( - ::google::protobuf::internal::ConstantInitialized); - - inline DisarmTrap(const DisarmTrap& from) : DisarmTrap(nullptr, from) {} - inline DisarmTrap(DisarmTrap&& from) noexcept - : DisarmTrap(nullptr, std::move(from)) {} - inline DisarmTrap& operator=(const DisarmTrap& from) { - CopyFrom(from); - return *this; - } - inline DisarmTrap& operator=(DisarmTrap&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const DisarmTrap& default_instance() { - return *internal_default_instance(); - } - static inline const DisarmTrap* internal_default_instance() { - return reinterpret_cast( - &_DisarmTrap_default_instance_); - } - static constexpr int kIndexInFileMessages = 25; - friend void swap(DisarmTrap& a, DisarmTrap& b) { a.Swap(&b); } - inline void Swap(DisarmTrap* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(DisarmTrap* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - DisarmTrap* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const DisarmTrap& from); - void MergeFrom(const DisarmTrap& from) { DisarmTrap::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(DisarmTrap* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.DisarmTrap"; } - - protected: - explicit DisarmTrap(::google::protobuf::Arena* arena); - DisarmTrap(::google::protobuf::Arena* arena, const DisarmTrap& from); - DisarmTrap(::google::protobuf::Arena* arena, DisarmTrap&& from) noexcept - : DisarmTrap(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIndexFieldNumber = 1, - }; - // uint32 index = 1; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.DisarmTrap) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const DisarmTrap& from_msg); - ::uint32_t index_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class ClearCursor final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.ClearCursor) */ { - public: - inline ClearCursor() : ClearCursor(nullptr) {} - ~ClearCursor() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ClearCursor* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ClearCursor)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ClearCursor( - ::google::protobuf::internal::ConstantInitialized); - - inline ClearCursor(const ClearCursor& from) : ClearCursor(nullptr, from) {} - inline ClearCursor(ClearCursor&& from) noexcept - : ClearCursor(nullptr, std::move(from)) {} - inline ClearCursor& operator=(const ClearCursor& from) { - CopyFrom(from); - return *this; - } - inline ClearCursor& operator=(ClearCursor&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ClearCursor& default_instance() { - return *internal_default_instance(); - } - static inline const ClearCursor* internal_default_instance() { - return reinterpret_cast( - &_ClearCursor_default_instance_); - } - static constexpr int kIndexInFileMessages = 31; - friend void swap(ClearCursor& a, ClearCursor& b) { a.Swap(&b); } - inline void Swap(ClearCursor* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClearCursor* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClearCursor* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ClearCursor& from); - void MergeFrom(const ClearCursor& from) { ClearCursor::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ClearCursor* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.ClearCursor"; } - - protected: - explicit ClearCursor(::google::protobuf::Arena* arena); - ClearCursor(::google::protobuf::Arena* arena, const ClearCursor& from); - ClearCursor(::google::protobuf::Arena* arena, ClearCursor&& from) noexcept - : ClearCursor(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.ClearCursor) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ClearCursor& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class CastXY final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.CastXY) */ { - public: - inline CastXY() : CastXY(nullptr) {} - ~CastXY() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(CastXY* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(CastXY)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR CastXY( - ::google::protobuf::internal::ConstantInitialized); - - inline CastXY(const CastXY& from) : CastXY(nullptr, from) {} - inline CastXY(CastXY&& from) noexcept - : CastXY(nullptr, std::move(from)) {} - inline CastXY& operator=(const CastXY& from) { - CopyFrom(from); - return *this; - } - inline CastXY& operator=(CastXY&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const CastXY& default_instance() { - return *internal_default_instance(); - } - static inline const CastXY* internal_default_instance() { - return reinterpret_cast( - &_CastXY_default_instance_); - } - static constexpr int kIndexInFileMessages = 18; - friend void swap(CastXY& a, CastXY& b) { a.Swap(&b); } - inline void Swap(CastXY* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CastXY* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CastXY* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const CastXY& from); - void MergeFrom(const CastXY& from) { CastXY::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(CastXY* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.CastXY"; } - - protected: - explicit CastXY(::google::protobuf::Arena* arena); - CastXY(::google::protobuf::Arena* arena, const CastXY& from); - CastXY(::google::protobuf::Arena* arena, CastXY&& from) noexcept - : CastXY(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kXFieldNumber = 1, - kYFieldNumber = 2, - }; - // sint32 x = 1; - void clear_x() ; - ::int32_t x() const; - void set_x(::int32_t value); - - private: - ::int32_t _internal_x() const; - void _internal_set_x(::int32_t value); - - public: - // sint32 y = 2; - void clear_y() ; - ::int32_t y() const; - void set_y(::int32_t value); - - private: - ::int32_t _internal_y() const; - void _internal_set_y(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.CastXY) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 1, 2, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const CastXY& from_msg); - ::int32_t x_; - ::int32_t y_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class CastMonster final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.CastMonster) */ { - public: - inline CastMonster() : CastMonster(nullptr) {} - ~CastMonster() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(CastMonster* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(CastMonster)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR CastMonster( - ::google::protobuf::internal::ConstantInitialized); - - inline CastMonster(const CastMonster& from) : CastMonster(nullptr, from) {} - inline CastMonster(CastMonster&& from) noexcept - : CastMonster(nullptr, std::move(from)) {} - inline CastMonster& operator=(const CastMonster& from) { - CopyFrom(from); - return *this; - } - inline CastMonster& operator=(CastMonster&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const CastMonster& default_instance() { - return *internal_default_instance(); - } - static inline const CastMonster* internal_default_instance() { - return reinterpret_cast( - &_CastMonster_default_instance_); - } - static constexpr int kIndexInFileMessages = 17; - friend void swap(CastMonster& a, CastMonster& b) { a.Swap(&b); } - inline void Swap(CastMonster* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CastMonster* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CastMonster* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const CastMonster& from); - void MergeFrom(const CastMonster& from) { CastMonster::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(CastMonster* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.CastMonster"; } - - protected: - explicit CastMonster(::google::protobuf::Arena* arena); - CastMonster(::google::protobuf::Arena* arena, const CastMonster& from); - CastMonster(::google::protobuf::Arena* arena, CastMonster&& from) noexcept - : CastMonster(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIndexFieldNumber = 1, - }; - // uint32 index = 1; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.CastMonster) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const CastMonster& from_msg); - ::uint32_t index_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class CancelQText final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.CancelQText) */ { - public: - inline CancelQText() : CancelQText(nullptr) {} - ~CancelQText() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(CancelQText* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(CancelQText)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR CancelQText( - ::google::protobuf::internal::ConstantInitialized); - - inline CancelQText(const CancelQText& from) : CancelQText(nullptr, from) {} - inline CancelQText(CancelQText&& from) noexcept - : CancelQText(nullptr, std::move(from)) {} - inline CancelQText& operator=(const CancelQText& from) { - CopyFrom(from); - return *this; - } - inline CancelQText& operator=(CancelQText&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const CancelQText& default_instance() { - return *internal_default_instance(); - } - static inline const CancelQText* internal_default_instance() { - return reinterpret_cast( - &_CancelQText_default_instance_); - } - static constexpr int kIndexInFileMessages = 1; - friend void swap(CancelQText& a, CancelQText& b) { a.Swap(&b); } - inline void Swap(CancelQText* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(CancelQText* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - CancelQText* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const CancelQText& from); - void MergeFrom(const CancelQText& from) { CancelQText::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(CancelQText* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.CancelQText"; } - - protected: - explicit CancelQText(::google::protobuf::Arena* arena); - CancelQText(::google::protobuf::Arena* arena, const CancelQText& from); - CancelQText(::google::protobuf::Arena* arena, CancelQText&& from) noexcept - : CancelQText(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.commands.CancelQText) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const CancelQText& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class BuyItem final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.BuyItem) */ { - public: - inline BuyItem() : BuyItem(nullptr) {} - ~BuyItem() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(BuyItem* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(BuyItem)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR BuyItem( - ::google::protobuf::internal::ConstantInitialized); - - inline BuyItem(const BuyItem& from) : BuyItem(nullptr, from) {} - inline BuyItem(BuyItem&& from) noexcept - : BuyItem(nullptr, std::move(from)) {} - inline BuyItem& operator=(const BuyItem& from) { - CopyFrom(from); - return *this; - } - inline BuyItem& operator=(BuyItem&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const BuyItem& default_instance() { - return *internal_default_instance(); - } - static inline const BuyItem* internal_default_instance() { - return reinterpret_cast( - &_BuyItem_default_instance_); - } - static constexpr int kIndexInFileMessages = 5; - friend void swap(BuyItem& a, BuyItem& b) { a.Swap(&b); } - inline void Swap(BuyItem* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(BuyItem* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - BuyItem* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const BuyItem& from); - void MergeFrom(const BuyItem& from) { BuyItem::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(BuyItem* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.BuyItem"; } - - protected: - explicit BuyItem(::google::protobuf::Arena* arena); - BuyItem(::google::protobuf::Arena* arena, const BuyItem& from); - BuyItem(::google::protobuf::Arena* arena, BuyItem&& from) noexcept - : BuyItem(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIDFieldNumber = 1, - }; - // 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: - // @@protoc_insertion_point(class_scope:dapi.commands.BuyItem) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const BuyItem& from_msg); - ::uint32_t id_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class AttackXY final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.AttackXY) */ { - public: - inline AttackXY() : AttackXY(nullptr) {} - ~AttackXY() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(AttackXY* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(AttackXY)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR AttackXY( - ::google::protobuf::internal::ConstantInitialized); - - inline AttackXY(const AttackXY& from) : AttackXY(nullptr, from) {} - inline AttackXY(AttackXY&& from) noexcept - : AttackXY(nullptr, std::move(from)) {} - inline AttackXY& operator=(const AttackXY& from) { - CopyFrom(from); - return *this; - } - inline AttackXY& operator=(AttackXY&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const AttackXY& default_instance() { - return *internal_default_instance(); - } - static inline const AttackXY* internal_default_instance() { - return reinterpret_cast( - &_AttackXY_default_instance_); - } - static constexpr int kIndexInFileMessages = 10; - friend void swap(AttackXY& a, AttackXY& b) { a.Swap(&b); } - inline void Swap(AttackXY* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(AttackXY* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AttackXY* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const AttackXY& from); - void MergeFrom(const AttackXY& from) { AttackXY::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(AttackXY* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.AttackXY"; } - - protected: - explicit AttackXY(::google::protobuf::Arena* arena); - AttackXY(::google::protobuf::Arena* arena, const AttackXY& from); - AttackXY(::google::protobuf::Arena* arena, AttackXY&& from) noexcept - : AttackXY(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<23> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kXFieldNumber = 1, - kYFieldNumber = 2, - }; - // sint32 x = 1; - void clear_x() ; - ::int32_t x() const; - void set_x(::int32_t value); - - private: - ::int32_t _internal_x() const; - void _internal_set_x(::int32_t value); - - public: - // sint32 y = 2; - void clear_y() ; - ::int32_t y() const; - void set_y(::int32_t value); - - private: - ::int32_t _internal_y() const; - void _internal_set_y(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.AttackXY) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 1, 2, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const AttackXY& from_msg); - ::int32_t x_; - ::int32_t y_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class AttackMonster final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.AttackMonster) */ { - public: - inline AttackMonster() : AttackMonster(nullptr) {} - ~AttackMonster() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(AttackMonster* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(AttackMonster)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR AttackMonster( - ::google::protobuf::internal::ConstantInitialized); - - inline AttackMonster(const AttackMonster& from) : AttackMonster(nullptr, from) {} - inline AttackMonster(AttackMonster&& from) noexcept - : AttackMonster(nullptr, std::move(from)) {} - inline AttackMonster& operator=(const AttackMonster& from) { - CopyFrom(from); - return *this; - } - inline AttackMonster& operator=(AttackMonster&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const AttackMonster& default_instance() { - return *internal_default_instance(); - } - static inline const AttackMonster* internal_default_instance() { - return reinterpret_cast( - &_AttackMonster_default_instance_); - } - static constexpr int kIndexInFileMessages = 9; - friend void swap(AttackMonster& a, AttackMonster& b) { a.Swap(&b); } - inline void Swap(AttackMonster* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(AttackMonster* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - AttackMonster* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const AttackMonster& from); - void MergeFrom(const AttackMonster& from) { AttackMonster::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(AttackMonster* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.AttackMonster"; } - - protected: - explicit AttackMonster(::google::protobuf::Arena* arena); - AttackMonster(::google::protobuf::Arena* arena, const AttackMonster& from); - AttackMonster(::google::protobuf::Arena* arena, AttackMonster&& from) noexcept - : AttackMonster(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<28> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIndexFieldNumber = 1, - }; - // uint32 index = 1; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.commands.AttackMonster) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const AttackMonster& from_msg); - ::uint32_t index_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; -// ------------------------------------------------------------------- - -class Command final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.commands.Command) */ { - public: - inline Command() : Command(nullptr) {} - ~Command() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Command* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Command)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR Command( - ::google::protobuf::internal::ConstantInitialized); - - inline Command(const Command& from) : Command(nullptr, from) {} - inline Command(Command&& from) noexcept - : Command(nullptr, std::move(from)) {} - inline Command& operator=(const Command& from) { - CopyFrom(from); - return *this; - } - inline Command& operator=(Command&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const Command& default_instance() { - return *internal_default_instance(); - } - enum CommandCase { - kMove = 1, - kTalk = 2, - kOption = 3, - kBuyItem = 4, - kSellItem = 5, - kRechargeItem = 6, - kRepairItem = 7, - kAttackMonster = 8, - kAttackXY = 9, - kOperateObject = 10, - kUseBeltItem = 11, - kToggleCharacterSheet = 12, - kIncreaseStat = 13, - kGetItem = 14, - kSetSpell = 15, - kCastMonster = 16, - kCastXY = 17, - kToggleInventory = 18, - kPutInCursor = 19, - kPutCursorItem = 20, - kDropCursorItem = 21, - kUseItem = 22, - kIdentifyStoreItem = 23, - kCancelQText = 24, - kSetFPS = 25, - kDisarmTrap = 26, - kSkillRepair = 27, - kSkillRecharge = 28, - kToggleMenu = 29, - kSaveGame = 30, - kQuit = 31, - kClearCursor = 32, - kIdentifyItem = 33, - COMMAND_NOT_SET = 0, - }; - static inline const Command* internal_default_instance() { - return reinterpret_cast( - &_Command_default_instance_); - } - static constexpr int kIndexInFileMessages = 33; - friend void swap(Command& a, Command& b) { a.Swap(&b); } - inline void Swap(Command* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Command* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Command* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const Command& from); - void MergeFrom(const Command& from) { Command::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(Command* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.commands.Command"; } - - protected: - explicit Command(::google::protobuf::Arena* arena); - Command(::google::protobuf::Arena* arena, const Command& from); - Command(::google::protobuf::Arena* arena, Command&& from) noexcept - : Command(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kMoveFieldNumber = 1, - kTalkFieldNumber = 2, - kOptionFieldNumber = 3, - kBuyItemFieldNumber = 4, - kSellItemFieldNumber = 5, - kRechargeItemFieldNumber = 6, - kRepairItemFieldNumber = 7, - kAttackMonsterFieldNumber = 8, - kAttackXYFieldNumber = 9, - kOperateObjectFieldNumber = 10, - kUseBeltItemFieldNumber = 11, - kToggleCharacterSheetFieldNumber = 12, - kIncreaseStatFieldNumber = 13, - kGetItemFieldNumber = 14, - kSetSpellFieldNumber = 15, - kCastMonsterFieldNumber = 16, - kCastXYFieldNumber = 17, - kToggleInventoryFieldNumber = 18, - kPutInCursorFieldNumber = 19, - kPutCursorItemFieldNumber = 20, - kDropCursorItemFieldNumber = 21, - kUseItemFieldNumber = 22, - kIdentifyStoreItemFieldNumber = 23, - kCancelQTextFieldNumber = 24, - kSetFPSFieldNumber = 25, - kDisarmTrapFieldNumber = 26, - kSkillRepairFieldNumber = 27, - kSkillRechargeFieldNumber = 28, - kToggleMenuFieldNumber = 29, - kSaveGameFieldNumber = 30, - kQuitFieldNumber = 31, - kClearCursorFieldNumber = 32, - kIdentifyItemFieldNumber = 33, - }; - // .dapi.commands.Move move = 1; - bool has_move() const; - private: - bool _internal_has_move() const; - - public: - void clear_move() ; - const ::dapi::commands::Move& move() const; - PROTOBUF_NODISCARD ::dapi::commands::Move* release_move(); - ::dapi::commands::Move* mutable_move(); - void set_allocated_move(::dapi::commands::Move* value); - void unsafe_arena_set_allocated_move(::dapi::commands::Move* value); - ::dapi::commands::Move* unsafe_arena_release_move(); - - private: - const ::dapi::commands::Move& _internal_move() const; - ::dapi::commands::Move* _internal_mutable_move(); - - public: - // .dapi.commands.Talk talk = 2; - bool has_talk() const; - private: - bool _internal_has_talk() const; - - public: - void clear_talk() ; - const ::dapi::commands::Talk& talk() const; - PROTOBUF_NODISCARD ::dapi::commands::Talk* release_talk(); - ::dapi::commands::Talk* mutable_talk(); - void set_allocated_talk(::dapi::commands::Talk* value); - void unsafe_arena_set_allocated_talk(::dapi::commands::Talk* value); - ::dapi::commands::Talk* unsafe_arena_release_talk(); - - private: - const ::dapi::commands::Talk& _internal_talk() const; - ::dapi::commands::Talk* _internal_mutable_talk(); - - public: - // .dapi.commands.SelectStoreOption option = 3; - bool has_option() const; - private: - bool _internal_has_option() const; - - public: - void clear_option() ; - const ::dapi::commands::SelectStoreOption& option() const; - PROTOBUF_NODISCARD ::dapi::commands::SelectStoreOption* release_option(); - ::dapi::commands::SelectStoreOption* mutable_option(); - void set_allocated_option(::dapi::commands::SelectStoreOption* value); - void unsafe_arena_set_allocated_option(::dapi::commands::SelectStoreOption* value); - ::dapi::commands::SelectStoreOption* unsafe_arena_release_option(); - - private: - const ::dapi::commands::SelectStoreOption& _internal_option() const; - ::dapi::commands::SelectStoreOption* _internal_mutable_option(); - - public: - // .dapi.commands.BuyItem buyItem = 4; - bool has_buyitem() const; - private: - bool _internal_has_buyitem() const; - - public: - void clear_buyitem() ; - const ::dapi::commands::BuyItem& buyitem() const; - PROTOBUF_NODISCARD ::dapi::commands::BuyItem* release_buyitem(); - ::dapi::commands::BuyItem* mutable_buyitem(); - void set_allocated_buyitem(::dapi::commands::BuyItem* value); - void unsafe_arena_set_allocated_buyitem(::dapi::commands::BuyItem* value); - ::dapi::commands::BuyItem* unsafe_arena_release_buyitem(); - - private: - const ::dapi::commands::BuyItem& _internal_buyitem() const; - ::dapi::commands::BuyItem* _internal_mutable_buyitem(); - - public: - // .dapi.commands.SellItem sellItem = 5; - bool has_sellitem() const; - private: - bool _internal_has_sellitem() const; - - public: - void clear_sellitem() ; - const ::dapi::commands::SellItem& sellitem() const; - PROTOBUF_NODISCARD ::dapi::commands::SellItem* release_sellitem(); - ::dapi::commands::SellItem* mutable_sellitem(); - void set_allocated_sellitem(::dapi::commands::SellItem* value); - void unsafe_arena_set_allocated_sellitem(::dapi::commands::SellItem* value); - ::dapi::commands::SellItem* unsafe_arena_release_sellitem(); - - private: - const ::dapi::commands::SellItem& _internal_sellitem() const; - ::dapi::commands::SellItem* _internal_mutable_sellitem(); - - public: - // .dapi.commands.RechargeItem rechargeItem = 6; - bool has_rechargeitem() const; - private: - bool _internal_has_rechargeitem() const; - - public: - void clear_rechargeitem() ; - const ::dapi::commands::RechargeItem& rechargeitem() const; - PROTOBUF_NODISCARD ::dapi::commands::RechargeItem* release_rechargeitem(); - ::dapi::commands::RechargeItem* mutable_rechargeitem(); - void set_allocated_rechargeitem(::dapi::commands::RechargeItem* value); - void unsafe_arena_set_allocated_rechargeitem(::dapi::commands::RechargeItem* value); - ::dapi::commands::RechargeItem* unsafe_arena_release_rechargeitem(); - - private: - const ::dapi::commands::RechargeItem& _internal_rechargeitem() const; - ::dapi::commands::RechargeItem* _internal_mutable_rechargeitem(); - - public: - // .dapi.commands.RepairItem repairItem = 7; - bool has_repairitem() const; - private: - bool _internal_has_repairitem() const; - - public: - void clear_repairitem() ; - const ::dapi::commands::RepairItem& repairitem() const; - PROTOBUF_NODISCARD ::dapi::commands::RepairItem* release_repairitem(); - ::dapi::commands::RepairItem* mutable_repairitem(); - void set_allocated_repairitem(::dapi::commands::RepairItem* value); - void unsafe_arena_set_allocated_repairitem(::dapi::commands::RepairItem* value); - ::dapi::commands::RepairItem* unsafe_arena_release_repairitem(); - - private: - const ::dapi::commands::RepairItem& _internal_repairitem() const; - ::dapi::commands::RepairItem* _internal_mutable_repairitem(); - - public: - // .dapi.commands.AttackMonster attackMonster = 8; - bool has_attackmonster() const; - private: - bool _internal_has_attackmonster() const; - - public: - void clear_attackmonster() ; - const ::dapi::commands::AttackMonster& attackmonster() const; - PROTOBUF_NODISCARD ::dapi::commands::AttackMonster* release_attackmonster(); - ::dapi::commands::AttackMonster* mutable_attackmonster(); - void set_allocated_attackmonster(::dapi::commands::AttackMonster* value); - void unsafe_arena_set_allocated_attackmonster(::dapi::commands::AttackMonster* value); - ::dapi::commands::AttackMonster* unsafe_arena_release_attackmonster(); - - private: - const ::dapi::commands::AttackMonster& _internal_attackmonster() const; - ::dapi::commands::AttackMonster* _internal_mutable_attackmonster(); - - public: - // .dapi.commands.AttackXY attackXY = 9; - bool has_attackxy() const; - private: - bool _internal_has_attackxy() const; - - public: - void clear_attackxy() ; - const ::dapi::commands::AttackXY& attackxy() const; - PROTOBUF_NODISCARD ::dapi::commands::AttackXY* release_attackxy(); - ::dapi::commands::AttackXY* mutable_attackxy(); - void set_allocated_attackxy(::dapi::commands::AttackXY* value); - void unsafe_arena_set_allocated_attackxy(::dapi::commands::AttackXY* value); - ::dapi::commands::AttackXY* unsafe_arena_release_attackxy(); - - private: - const ::dapi::commands::AttackXY& _internal_attackxy() const; - ::dapi::commands::AttackXY* _internal_mutable_attackxy(); - - public: - // .dapi.commands.OperateObject operateObject = 10; - bool has_operateobject() const; - private: - bool _internal_has_operateobject() const; - - public: - void clear_operateobject() ; - const ::dapi::commands::OperateObject& operateobject() const; - PROTOBUF_NODISCARD ::dapi::commands::OperateObject* release_operateobject(); - ::dapi::commands::OperateObject* mutable_operateobject(); - void set_allocated_operateobject(::dapi::commands::OperateObject* value); - void unsafe_arena_set_allocated_operateobject(::dapi::commands::OperateObject* value); - ::dapi::commands::OperateObject* unsafe_arena_release_operateobject(); - - private: - const ::dapi::commands::OperateObject& _internal_operateobject() const; - ::dapi::commands::OperateObject* _internal_mutable_operateobject(); - - public: - // .dapi.commands.UseBeltItem useBeltItem = 11; - bool has_usebeltitem() const; - private: - bool _internal_has_usebeltitem() const; - - public: - void clear_usebeltitem() ; - const ::dapi::commands::UseBeltItem& usebeltitem() const; - PROTOBUF_NODISCARD ::dapi::commands::UseBeltItem* release_usebeltitem(); - ::dapi::commands::UseBeltItem* mutable_usebeltitem(); - void set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value); - void unsafe_arena_set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value); - ::dapi::commands::UseBeltItem* unsafe_arena_release_usebeltitem(); - - private: - const ::dapi::commands::UseBeltItem& _internal_usebeltitem() const; - ::dapi::commands::UseBeltItem* _internal_mutable_usebeltitem(); - - public: - // .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; - bool has_togglecharactersheet() const; - private: - bool _internal_has_togglecharactersheet() const; - - public: - void clear_togglecharactersheet() ; - const ::dapi::commands::ToggleCharacterSheet& togglecharactersheet() const; - PROTOBUF_NODISCARD ::dapi::commands::ToggleCharacterSheet* release_togglecharactersheet(); - ::dapi::commands::ToggleCharacterSheet* mutable_togglecharactersheet(); - void set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value); - void unsafe_arena_set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value); - ::dapi::commands::ToggleCharacterSheet* unsafe_arena_release_togglecharactersheet(); - - private: - const ::dapi::commands::ToggleCharacterSheet& _internal_togglecharactersheet() const; - ::dapi::commands::ToggleCharacterSheet* _internal_mutable_togglecharactersheet(); - - public: - // .dapi.commands.IncreaseStat increaseStat = 13; - bool has_increasestat() const; - private: - bool _internal_has_increasestat() const; - - public: - void clear_increasestat() ; - const ::dapi::commands::IncreaseStat& increasestat() const; - PROTOBUF_NODISCARD ::dapi::commands::IncreaseStat* release_increasestat(); - ::dapi::commands::IncreaseStat* mutable_increasestat(); - void set_allocated_increasestat(::dapi::commands::IncreaseStat* value); - void unsafe_arena_set_allocated_increasestat(::dapi::commands::IncreaseStat* value); - ::dapi::commands::IncreaseStat* unsafe_arena_release_increasestat(); - - private: - const ::dapi::commands::IncreaseStat& _internal_increasestat() const; - ::dapi::commands::IncreaseStat* _internal_mutable_increasestat(); - - public: - // .dapi.commands.GetItem getItem = 14; - bool has_getitem() const; - private: - bool _internal_has_getitem() const; - - public: - void clear_getitem() ; - const ::dapi::commands::GetItem& getitem() const; - PROTOBUF_NODISCARD ::dapi::commands::GetItem* release_getitem(); - ::dapi::commands::GetItem* mutable_getitem(); - void set_allocated_getitem(::dapi::commands::GetItem* value); - void unsafe_arena_set_allocated_getitem(::dapi::commands::GetItem* value); - ::dapi::commands::GetItem* unsafe_arena_release_getitem(); - - private: - const ::dapi::commands::GetItem& _internal_getitem() const; - ::dapi::commands::GetItem* _internal_mutable_getitem(); - - public: - // .dapi.commands.SetSpell setSpell = 15; - bool has_setspell() const; - private: - bool _internal_has_setspell() const; - - public: - void clear_setspell() ; - const ::dapi::commands::SetSpell& setspell() const; - PROTOBUF_NODISCARD ::dapi::commands::SetSpell* release_setspell(); - ::dapi::commands::SetSpell* mutable_setspell(); - void set_allocated_setspell(::dapi::commands::SetSpell* value); - void unsafe_arena_set_allocated_setspell(::dapi::commands::SetSpell* value); - ::dapi::commands::SetSpell* unsafe_arena_release_setspell(); - - private: - const ::dapi::commands::SetSpell& _internal_setspell() const; - ::dapi::commands::SetSpell* _internal_mutable_setspell(); - - public: - // .dapi.commands.CastMonster castMonster = 16; - bool has_castmonster() const; - private: - bool _internal_has_castmonster() const; - - public: - void clear_castmonster() ; - const ::dapi::commands::CastMonster& castmonster() const; - PROTOBUF_NODISCARD ::dapi::commands::CastMonster* release_castmonster(); - ::dapi::commands::CastMonster* mutable_castmonster(); - void set_allocated_castmonster(::dapi::commands::CastMonster* value); - void unsafe_arena_set_allocated_castmonster(::dapi::commands::CastMonster* value); - ::dapi::commands::CastMonster* unsafe_arena_release_castmonster(); - - private: - const ::dapi::commands::CastMonster& _internal_castmonster() const; - ::dapi::commands::CastMonster* _internal_mutable_castmonster(); - - public: - // .dapi.commands.CastXY castXY = 17; - bool has_castxy() const; - private: - bool _internal_has_castxy() const; - - public: - void clear_castxy() ; - const ::dapi::commands::CastXY& castxy() const; - PROTOBUF_NODISCARD ::dapi::commands::CastXY* release_castxy(); - ::dapi::commands::CastXY* mutable_castxy(); - void set_allocated_castxy(::dapi::commands::CastXY* value); - void unsafe_arena_set_allocated_castxy(::dapi::commands::CastXY* value); - ::dapi::commands::CastXY* unsafe_arena_release_castxy(); - - private: - const ::dapi::commands::CastXY& _internal_castxy() const; - ::dapi::commands::CastXY* _internal_mutable_castxy(); - - public: - // .dapi.commands.ToggleInventory toggleInventory = 18; - bool has_toggleinventory() const; - private: - bool _internal_has_toggleinventory() const; - - public: - void clear_toggleinventory() ; - const ::dapi::commands::ToggleInventory& toggleinventory() const; - PROTOBUF_NODISCARD ::dapi::commands::ToggleInventory* release_toggleinventory(); - ::dapi::commands::ToggleInventory* mutable_toggleinventory(); - void set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value); - void unsafe_arena_set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value); - ::dapi::commands::ToggleInventory* unsafe_arena_release_toggleinventory(); - - private: - const ::dapi::commands::ToggleInventory& _internal_toggleinventory() const; - ::dapi::commands::ToggleInventory* _internal_mutable_toggleinventory(); - - public: - // .dapi.commands.PutInCursor putInCursor = 19; - bool has_putincursor() const; - private: - bool _internal_has_putincursor() const; - - public: - void clear_putincursor() ; - const ::dapi::commands::PutInCursor& putincursor() const; - PROTOBUF_NODISCARD ::dapi::commands::PutInCursor* release_putincursor(); - ::dapi::commands::PutInCursor* mutable_putincursor(); - void set_allocated_putincursor(::dapi::commands::PutInCursor* value); - void unsafe_arena_set_allocated_putincursor(::dapi::commands::PutInCursor* value); - ::dapi::commands::PutInCursor* unsafe_arena_release_putincursor(); - - private: - const ::dapi::commands::PutInCursor& _internal_putincursor() const; - ::dapi::commands::PutInCursor* _internal_mutable_putincursor(); - - public: - // .dapi.commands.PutCursorItem putCursorItem = 20; - bool has_putcursoritem() const; - private: - bool _internal_has_putcursoritem() const; - - public: - void clear_putcursoritem() ; - const ::dapi::commands::PutCursorItem& putcursoritem() const; - PROTOBUF_NODISCARD ::dapi::commands::PutCursorItem* release_putcursoritem(); - ::dapi::commands::PutCursorItem* mutable_putcursoritem(); - void set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value); - void unsafe_arena_set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value); - ::dapi::commands::PutCursorItem* unsafe_arena_release_putcursoritem(); - - private: - const ::dapi::commands::PutCursorItem& _internal_putcursoritem() const; - ::dapi::commands::PutCursorItem* _internal_mutable_putcursoritem(); - - public: - // .dapi.commands.DropCursorItem dropCursorItem = 21; - bool has_dropcursoritem() const; - private: - bool _internal_has_dropcursoritem() const; - - public: - void clear_dropcursoritem() ; - const ::dapi::commands::DropCursorItem& dropcursoritem() const; - PROTOBUF_NODISCARD ::dapi::commands::DropCursorItem* release_dropcursoritem(); - ::dapi::commands::DropCursorItem* mutable_dropcursoritem(); - void set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value); - void unsafe_arena_set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value); - ::dapi::commands::DropCursorItem* unsafe_arena_release_dropcursoritem(); - - private: - const ::dapi::commands::DropCursorItem& _internal_dropcursoritem() const; - ::dapi::commands::DropCursorItem* _internal_mutable_dropcursoritem(); - - public: - // .dapi.commands.UseItem useItem = 22; - bool has_useitem() const; - private: - bool _internal_has_useitem() const; - - public: - void clear_useitem() ; - const ::dapi::commands::UseItem& useitem() const; - PROTOBUF_NODISCARD ::dapi::commands::UseItem* release_useitem(); - ::dapi::commands::UseItem* mutable_useitem(); - void set_allocated_useitem(::dapi::commands::UseItem* value); - void unsafe_arena_set_allocated_useitem(::dapi::commands::UseItem* value); - ::dapi::commands::UseItem* unsafe_arena_release_useitem(); - - private: - const ::dapi::commands::UseItem& _internal_useitem() const; - ::dapi::commands::UseItem* _internal_mutable_useitem(); - - public: - // .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; - bool has_identifystoreitem() const; - private: - bool _internal_has_identifystoreitem() const; - - public: - void clear_identifystoreitem() ; - const ::dapi::commands::IdentifyStoreItem& identifystoreitem() const; - PROTOBUF_NODISCARD ::dapi::commands::IdentifyStoreItem* release_identifystoreitem(); - ::dapi::commands::IdentifyStoreItem* mutable_identifystoreitem(); - void set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value); - void unsafe_arena_set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value); - ::dapi::commands::IdentifyStoreItem* unsafe_arena_release_identifystoreitem(); - - private: - const ::dapi::commands::IdentifyStoreItem& _internal_identifystoreitem() const; - ::dapi::commands::IdentifyStoreItem* _internal_mutable_identifystoreitem(); - - public: - // .dapi.commands.CancelQText cancelQText = 24; - bool has_cancelqtext() const; - private: - bool _internal_has_cancelqtext() const; - - public: - void clear_cancelqtext() ; - const ::dapi::commands::CancelQText& cancelqtext() const; - PROTOBUF_NODISCARD ::dapi::commands::CancelQText* release_cancelqtext(); - ::dapi::commands::CancelQText* mutable_cancelqtext(); - void set_allocated_cancelqtext(::dapi::commands::CancelQText* value); - void unsafe_arena_set_allocated_cancelqtext(::dapi::commands::CancelQText* value); - ::dapi::commands::CancelQText* unsafe_arena_release_cancelqtext(); - - private: - const ::dapi::commands::CancelQText& _internal_cancelqtext() const; - ::dapi::commands::CancelQText* _internal_mutable_cancelqtext(); - - public: - // .dapi.commands.SetFPS setFPS = 25; - bool has_setfps() const; - private: - bool _internal_has_setfps() const; - - public: - void clear_setfps() ; - const ::dapi::commands::SetFPS& setfps() const; - PROTOBUF_NODISCARD ::dapi::commands::SetFPS* release_setfps(); - ::dapi::commands::SetFPS* mutable_setfps(); - void set_allocated_setfps(::dapi::commands::SetFPS* value); - void unsafe_arena_set_allocated_setfps(::dapi::commands::SetFPS* value); - ::dapi::commands::SetFPS* unsafe_arena_release_setfps(); - - private: - const ::dapi::commands::SetFPS& _internal_setfps() const; - ::dapi::commands::SetFPS* _internal_mutable_setfps(); - - public: - // .dapi.commands.DisarmTrap disarmTrap = 26; - bool has_disarmtrap() const; - private: - bool _internal_has_disarmtrap() const; - - public: - void clear_disarmtrap() ; - const ::dapi::commands::DisarmTrap& disarmtrap() const; - PROTOBUF_NODISCARD ::dapi::commands::DisarmTrap* release_disarmtrap(); - ::dapi::commands::DisarmTrap* mutable_disarmtrap(); - void set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value); - void unsafe_arena_set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value); - ::dapi::commands::DisarmTrap* unsafe_arena_release_disarmtrap(); - - private: - const ::dapi::commands::DisarmTrap& _internal_disarmtrap() const; - ::dapi::commands::DisarmTrap* _internal_mutable_disarmtrap(); - - public: - // .dapi.commands.SkillRepair skillRepair = 27; - bool has_skillrepair() const; - private: - bool _internal_has_skillrepair() const; - - public: - void clear_skillrepair() ; - const ::dapi::commands::SkillRepair& skillrepair() const; - PROTOBUF_NODISCARD ::dapi::commands::SkillRepair* release_skillrepair(); - ::dapi::commands::SkillRepair* mutable_skillrepair(); - void set_allocated_skillrepair(::dapi::commands::SkillRepair* value); - void unsafe_arena_set_allocated_skillrepair(::dapi::commands::SkillRepair* value); - ::dapi::commands::SkillRepair* unsafe_arena_release_skillrepair(); - - private: - const ::dapi::commands::SkillRepair& _internal_skillrepair() const; - ::dapi::commands::SkillRepair* _internal_mutable_skillrepair(); - - public: - // .dapi.commands.SkillRecharge skillRecharge = 28; - bool has_skillrecharge() const; - private: - bool _internal_has_skillrecharge() const; - - public: - void clear_skillrecharge() ; - const ::dapi::commands::SkillRecharge& skillrecharge() const; - PROTOBUF_NODISCARD ::dapi::commands::SkillRecharge* release_skillrecharge(); - ::dapi::commands::SkillRecharge* mutable_skillrecharge(); - void set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value); - void unsafe_arena_set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value); - ::dapi::commands::SkillRecharge* unsafe_arena_release_skillrecharge(); - - private: - const ::dapi::commands::SkillRecharge& _internal_skillrecharge() const; - ::dapi::commands::SkillRecharge* _internal_mutable_skillrecharge(); - - public: - // .dapi.commands.ToggleMenu toggleMenu = 29; - bool has_togglemenu() const; - private: - bool _internal_has_togglemenu() const; - - public: - void clear_togglemenu() ; - const ::dapi::commands::ToggleMenu& togglemenu() const; - PROTOBUF_NODISCARD ::dapi::commands::ToggleMenu* release_togglemenu(); - ::dapi::commands::ToggleMenu* mutable_togglemenu(); - void set_allocated_togglemenu(::dapi::commands::ToggleMenu* value); - void unsafe_arena_set_allocated_togglemenu(::dapi::commands::ToggleMenu* value); - ::dapi::commands::ToggleMenu* unsafe_arena_release_togglemenu(); - - private: - const ::dapi::commands::ToggleMenu& _internal_togglemenu() const; - ::dapi::commands::ToggleMenu* _internal_mutable_togglemenu(); - - public: - // .dapi.commands.SaveGame saveGame = 30; - bool has_savegame() const; - private: - bool _internal_has_savegame() const; - - public: - void clear_savegame() ; - const ::dapi::commands::SaveGame& savegame() const; - PROTOBUF_NODISCARD ::dapi::commands::SaveGame* release_savegame(); - ::dapi::commands::SaveGame* mutable_savegame(); - void set_allocated_savegame(::dapi::commands::SaveGame* value); - void unsafe_arena_set_allocated_savegame(::dapi::commands::SaveGame* value); - ::dapi::commands::SaveGame* unsafe_arena_release_savegame(); - - private: - const ::dapi::commands::SaveGame& _internal_savegame() const; - ::dapi::commands::SaveGame* _internal_mutable_savegame(); - - public: - // .dapi.commands.Quit quit = 31; - bool has_quit() const; - private: - bool _internal_has_quit() const; - - public: - void clear_quit() ; - const ::dapi::commands::Quit& quit() const; - PROTOBUF_NODISCARD ::dapi::commands::Quit* release_quit(); - ::dapi::commands::Quit* mutable_quit(); - void set_allocated_quit(::dapi::commands::Quit* value); - void unsafe_arena_set_allocated_quit(::dapi::commands::Quit* value); - ::dapi::commands::Quit* unsafe_arena_release_quit(); - - private: - const ::dapi::commands::Quit& _internal_quit() const; - ::dapi::commands::Quit* _internal_mutable_quit(); - - public: - // .dapi.commands.ClearCursor clearCursor = 32; - bool has_clearcursor() const; - private: - bool _internal_has_clearcursor() const; - - public: - void clear_clearcursor() ; - const ::dapi::commands::ClearCursor& clearcursor() const; - PROTOBUF_NODISCARD ::dapi::commands::ClearCursor* release_clearcursor(); - ::dapi::commands::ClearCursor* mutable_clearcursor(); - void set_allocated_clearcursor(::dapi::commands::ClearCursor* value); - void unsafe_arena_set_allocated_clearcursor(::dapi::commands::ClearCursor* value); - ::dapi::commands::ClearCursor* unsafe_arena_release_clearcursor(); - - private: - const ::dapi::commands::ClearCursor& _internal_clearcursor() const; - ::dapi::commands::ClearCursor* _internal_mutable_clearcursor(); - - public: - // .dapi.commands.IdentifyItem identifyItem = 33; - bool has_identifyitem() const; - private: - bool _internal_has_identifyitem() const; - - public: - void clear_identifyitem() ; - const ::dapi::commands::IdentifyItem& identifyitem() const; - PROTOBUF_NODISCARD ::dapi::commands::IdentifyItem* release_identifyitem(); - ::dapi::commands::IdentifyItem* mutable_identifyitem(); - void set_allocated_identifyitem(::dapi::commands::IdentifyItem* value); - void unsafe_arena_set_allocated_identifyitem(::dapi::commands::IdentifyItem* value); - ::dapi::commands::IdentifyItem* unsafe_arena_release_identifyitem(); - - private: - const ::dapi::commands::IdentifyItem& _internal_identifyitem() const; - ::dapi::commands::IdentifyItem* _internal_mutable_identifyitem(); - - public: - void clear_command(); - CommandCase command_case() const; - // @@protoc_insertion_point(class_scope:dapi.commands.Command) - private: - class _Internal; - void set_has_move(); - void set_has_talk(); - void set_has_option(); - void set_has_buyitem(); - void set_has_sellitem(); - void set_has_rechargeitem(); - void set_has_repairitem(); - void set_has_attackmonster(); - void set_has_attackxy(); - void set_has_operateobject(); - void set_has_usebeltitem(); - void set_has_togglecharactersheet(); - void set_has_increasestat(); - void set_has_getitem(); - void set_has_setspell(); - void set_has_castmonster(); - void set_has_castxy(); - void set_has_toggleinventory(); - void set_has_putincursor(); - void set_has_putcursoritem(); - void set_has_dropcursoritem(); - void set_has_useitem(); - void set_has_identifystoreitem(); - void set_has_cancelqtext(); - void set_has_setfps(); - void set_has_disarmtrap(); - void set_has_skillrepair(); - void set_has_skillrecharge(); - void set_has_togglemenu(); - void set_has_savegame(); - void set_has_quit(); - void set_has_clearcursor(); - void set_has_identifyitem(); - inline bool has_command() const; - inline void clear_has_command(); - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 33, 33, - 0, 7> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const Command& from_msg); - union CommandUnion { - constexpr CommandUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::dapi::commands::Move* move_; - ::dapi::commands::Talk* talk_; - ::dapi::commands::SelectStoreOption* option_; - ::dapi::commands::BuyItem* buyitem_; - ::dapi::commands::SellItem* sellitem_; - ::dapi::commands::RechargeItem* rechargeitem_; - ::dapi::commands::RepairItem* repairitem_; - ::dapi::commands::AttackMonster* attackmonster_; - ::dapi::commands::AttackXY* attackxy_; - ::dapi::commands::OperateObject* operateobject_; - ::dapi::commands::UseBeltItem* usebeltitem_; - ::dapi::commands::ToggleCharacterSheet* togglecharactersheet_; - ::dapi::commands::IncreaseStat* increasestat_; - ::dapi::commands::GetItem* getitem_; - ::dapi::commands::SetSpell* setspell_; - ::dapi::commands::CastMonster* castmonster_; - ::dapi::commands::CastXY* castxy_; - ::dapi::commands::ToggleInventory* toggleinventory_; - ::dapi::commands::PutInCursor* putincursor_; - ::dapi::commands::PutCursorItem* putcursoritem_; - ::dapi::commands::DropCursorItem* dropcursoritem_; - ::dapi::commands::UseItem* useitem_; - ::dapi::commands::IdentifyStoreItem* identifystoreitem_; - ::dapi::commands::CancelQText* cancelqtext_; - ::dapi::commands::SetFPS* setfps_; - ::dapi::commands::DisarmTrap* disarmtrap_; - ::dapi::commands::SkillRepair* skillrepair_; - ::dapi::commands::SkillRecharge* skillrecharge_; - ::dapi::commands::ToggleMenu* togglemenu_; - ::dapi::commands::SaveGame* savegame_; - ::dapi::commands::Quit* quit_; - ::dapi::commands::ClearCursor* clearcursor_; - ::dapi::commands::IdentifyItem* identifyitem_; - } command_; - ::google::protobuf::internal::CachedSize _cached_size_; - ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_command_2eproto; -}; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// SetFPS - -// uint32 FPS = 1; -inline void SetFPS::clear_fps() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fps_ = 0u; -} -inline ::uint32_t SetFPS::fps() const { - // @@protoc_insertion_point(field_get:dapi.commands.SetFPS.FPS) - return _internal_fps(); -} -inline void SetFPS::set_fps(::uint32_t value) { - _internal_set_fps(value); - // @@protoc_insertion_point(field_set:dapi.commands.SetFPS.FPS) -} -inline ::uint32_t SetFPS::_internal_fps() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.fps_; -} -inline void SetFPS::_internal_set_fps(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fps_ = value; -} - -// ------------------------------------------------------------------- - -// CancelQText - -// ------------------------------------------------------------------- - -// Move - -// uint32 type = 1; -inline void Move::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0u; -} -inline ::uint32_t Move::type() const { - // @@protoc_insertion_point(field_get:dapi.commands.Move.type) - return _internal_type(); -} -inline void Move::set_type(::uint32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.commands.Move.type) -} -inline ::uint32_t Move::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void Move::_internal_set_type(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// uint32 targetX = 2; -inline void Move::clear_targetx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targetx_ = 0u; -} -inline ::uint32_t Move::targetx() const { - // @@protoc_insertion_point(field_get:dapi.commands.Move.targetX) - return _internal_targetx(); -} -inline void Move::set_targetx(::uint32_t value) { - _internal_set_targetx(value); - // @@protoc_insertion_point(field_set:dapi.commands.Move.targetX) -} -inline ::uint32_t Move::_internal_targetx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.targetx_; -} -inline void Move::_internal_set_targetx(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targetx_ = value; -} - -// uint32 targetY = 3; -inline void Move::clear_targety() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targety_ = 0u; -} -inline ::uint32_t Move::targety() const { - // @@protoc_insertion_point(field_get:dapi.commands.Move.targetY) - return _internal_targety(); -} -inline void Move::set_targety(::uint32_t value) { - _internal_set_targety(value); - // @@protoc_insertion_point(field_set:dapi.commands.Move.targetY) -} -inline ::uint32_t Move::_internal_targety() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.targety_; -} -inline void Move::_internal_set_targety(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targety_ = value; -} - -// ------------------------------------------------------------------- - -// Talk - -// uint32 targetX = 1; -inline void Talk::clear_targetx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targetx_ = 0u; -} -inline ::uint32_t Talk::targetx() const { - // @@protoc_insertion_point(field_get:dapi.commands.Talk.targetX) - return _internal_targetx(); -} -inline void Talk::set_targetx(::uint32_t value) { - _internal_set_targetx(value); - // @@protoc_insertion_point(field_set:dapi.commands.Talk.targetX) -} -inline ::uint32_t Talk::_internal_targetx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.targetx_; -} -inline void Talk::_internal_set_targetx(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targetx_ = value; -} - -// uint32 targetY = 2; -inline void Talk::clear_targety() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targety_ = 0u; -} -inline ::uint32_t Talk::targety() const { - // @@protoc_insertion_point(field_get:dapi.commands.Talk.targetY) - return _internal_targety(); -} -inline void Talk::set_targety(::uint32_t value) { - _internal_set_targety(value); - // @@protoc_insertion_point(field_set:dapi.commands.Talk.targetY) -} -inline ::uint32_t Talk::_internal_targety() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.targety_; -} -inline void Talk::_internal_set_targety(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.targety_ = value; -} - -// ------------------------------------------------------------------- - -// SelectStoreOption - -// uint32 option = 1; -inline void SelectStoreOption::clear_option() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.option_ = 0u; -} -inline ::uint32_t SelectStoreOption::option() const { - // @@protoc_insertion_point(field_get:dapi.commands.SelectStoreOption.option) - return _internal_option(); -} -inline void SelectStoreOption::set_option(::uint32_t value) { - _internal_set_option(value); - // @@protoc_insertion_point(field_set:dapi.commands.SelectStoreOption.option) -} -inline ::uint32_t SelectStoreOption::_internal_option() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.option_; -} -inline void SelectStoreOption::_internal_set_option(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.option_ = value; -} - -// ------------------------------------------------------------------- - -// BuyItem - -// uint32 ID = 1; -inline void BuyItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t BuyItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.BuyItem.ID) - return _internal_id(); -} -inline void BuyItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.BuyItem.ID) -} -inline ::uint32_t BuyItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void BuyItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// SellItem - -// uint32 ID = 1; -inline void SellItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t SellItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.SellItem.ID) - return _internal_id(); -} -inline void SellItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.SellItem.ID) -} -inline ::uint32_t SellItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void SellItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// RechargeItem - -// uint32 ID = 1; -inline void RechargeItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t RechargeItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.RechargeItem.ID) - return _internal_id(); -} -inline void RechargeItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.RechargeItem.ID) -} -inline ::uint32_t RechargeItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void RechargeItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// RepairItem - -// uint32 ID = 1; -inline void RepairItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t RepairItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.RepairItem.ID) - return _internal_id(); -} -inline void RepairItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.RepairItem.ID) -} -inline ::uint32_t RepairItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void RepairItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// AttackMonster - -// uint32 index = 1; -inline void AttackMonster::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t AttackMonster::index() const { - // @@protoc_insertion_point(field_get:dapi.commands.AttackMonster.index) - return _internal_index(); -} -inline void AttackMonster::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.commands.AttackMonster.index) -} -inline ::uint32_t AttackMonster::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void AttackMonster::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// ------------------------------------------------------------------- - -// AttackXY - -// sint32 x = 1; -inline void AttackXY::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0; -} -inline ::int32_t AttackXY::x() const { - // @@protoc_insertion_point(field_get:dapi.commands.AttackXY.x) - return _internal_x(); -} -inline void AttackXY::set_x(::int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.commands.AttackXY.x) -} -inline ::int32_t AttackXY::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void AttackXY::_internal_set_x(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// sint32 y = 2; -inline void AttackXY::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0; -} -inline ::int32_t AttackXY::y() const { - // @@protoc_insertion_point(field_get:dapi.commands.AttackXY.y) - return _internal_y(); -} -inline void AttackXY::set_y(::int32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.commands.AttackXY.y) -} -inline ::int32_t AttackXY::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void AttackXY::_internal_set_y(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// ------------------------------------------------------------------- - -// OperateObject - -// uint32 index = 1; -inline void OperateObject::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t OperateObject::index() const { - // @@protoc_insertion_point(field_get:dapi.commands.OperateObject.index) - return _internal_index(); -} -inline void OperateObject::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.commands.OperateObject.index) -} -inline ::uint32_t OperateObject::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void OperateObject::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// ------------------------------------------------------------------- - -// UseBeltItem - -// uint32 slot = 1; -inline void UseBeltItem::clear_slot() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.slot_ = 0u; -} -inline ::uint32_t UseBeltItem::slot() const { - // @@protoc_insertion_point(field_get:dapi.commands.UseBeltItem.slot) - return _internal_slot(); -} -inline void UseBeltItem::set_slot(::uint32_t value) { - _internal_set_slot(value); - // @@protoc_insertion_point(field_set:dapi.commands.UseBeltItem.slot) -} -inline ::uint32_t UseBeltItem::_internal_slot() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.slot_; -} -inline void UseBeltItem::_internal_set_slot(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.slot_ = value; -} - -// ------------------------------------------------------------------- - -// ToggleCharacterSheet - -// ------------------------------------------------------------------- - -// IncreaseStat - -// uint32 stat = 1; -inline void IncreaseStat::clear_stat() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stat_ = 0u; -} -inline ::uint32_t IncreaseStat::stat() const { - // @@protoc_insertion_point(field_get:dapi.commands.IncreaseStat.stat) - return _internal_stat(); -} -inline void IncreaseStat::set_stat(::uint32_t value) { - _internal_set_stat(value); - // @@protoc_insertion_point(field_set:dapi.commands.IncreaseStat.stat) -} -inline ::uint32_t IncreaseStat::_internal_stat() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.stat_; -} -inline void IncreaseStat::_internal_set_stat(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stat_ = value; -} - -// ------------------------------------------------------------------- - -// GetItem - -// uint32 ID = 1; -inline void GetItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t GetItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.GetItem.ID) - return _internal_id(); -} -inline void GetItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.GetItem.ID) -} -inline ::uint32_t GetItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void GetItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// SetSpell - -// sint32 spellID = 1; -inline void SetSpell::clear_spellid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.spellid_ = 0; -} -inline ::int32_t SetSpell::spellid() const { - // @@protoc_insertion_point(field_get:dapi.commands.SetSpell.spellID) - return _internal_spellid(); -} -inline void SetSpell::set_spellid(::int32_t value) { - _internal_set_spellid(value); - // @@protoc_insertion_point(field_set:dapi.commands.SetSpell.spellID) -} -inline ::int32_t SetSpell::_internal_spellid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.spellid_; -} -inline void SetSpell::_internal_set_spellid(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.spellid_ = value; -} - -// sint32 spellType = 2; -inline void SetSpell::clear_spelltype() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.spelltype_ = 0; -} -inline ::int32_t SetSpell::spelltype() const { - // @@protoc_insertion_point(field_get:dapi.commands.SetSpell.spellType) - return _internal_spelltype(); -} -inline void SetSpell::set_spelltype(::int32_t value) { - _internal_set_spelltype(value); - // @@protoc_insertion_point(field_set:dapi.commands.SetSpell.spellType) -} -inline ::int32_t SetSpell::_internal_spelltype() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.spelltype_; -} -inline void SetSpell::_internal_set_spelltype(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.spelltype_ = value; -} - -// ------------------------------------------------------------------- - -// CastMonster - -// uint32 index = 1; -inline void CastMonster::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t CastMonster::index() const { - // @@protoc_insertion_point(field_get:dapi.commands.CastMonster.index) - return _internal_index(); -} -inline void CastMonster::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.commands.CastMonster.index) -} -inline ::uint32_t CastMonster::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void CastMonster::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// ------------------------------------------------------------------- - -// CastXY - -// sint32 x = 1; -inline void CastXY::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0; -} -inline ::int32_t CastXY::x() const { - // @@protoc_insertion_point(field_get:dapi.commands.CastXY.x) - return _internal_x(); -} -inline void CastXY::set_x(::int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.commands.CastXY.x) -} -inline ::int32_t CastXY::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void CastXY::_internal_set_x(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// sint32 y = 2; -inline void CastXY::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0; -} -inline ::int32_t CastXY::y() const { - // @@protoc_insertion_point(field_get:dapi.commands.CastXY.y) - return _internal_y(); -} -inline void CastXY::set_y(::int32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.commands.CastXY.y) -} -inline ::int32_t CastXY::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void CastXY::_internal_set_y(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// ------------------------------------------------------------------- - -// ToggleInventory - -// ------------------------------------------------------------------- - -// PutInCursor - -// uint32 ID = 1; -inline void PutInCursor::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t PutInCursor::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.PutInCursor.ID) - return _internal_id(); -} -inline void PutInCursor::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.PutInCursor.ID) -} -inline ::uint32_t PutInCursor::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void PutInCursor::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// PutCursorItem - -// sint32 target = 1; -inline void PutCursorItem::clear_target() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.target_ = 0; -} -inline ::int32_t PutCursorItem::target() const { - // @@protoc_insertion_point(field_get:dapi.commands.PutCursorItem.target) - return _internal_target(); -} -inline void PutCursorItem::set_target(::int32_t value) { - _internal_set_target(value); - // @@protoc_insertion_point(field_set:dapi.commands.PutCursorItem.target) -} -inline ::int32_t PutCursorItem::_internal_target() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.target_; -} -inline void PutCursorItem::_internal_set_target(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.target_ = value; -} - -// ------------------------------------------------------------------- - -// DropCursorItem - -// ------------------------------------------------------------------- - -// UseItem - -// uint32 ID = 1; -inline void UseItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t UseItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.UseItem.ID) - return _internal_id(); -} -inline void UseItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.UseItem.ID) -} -inline ::uint32_t UseItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void UseItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// IdentifyStoreItem - -// uint32 ID = 1; -inline void IdentifyStoreItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t IdentifyStoreItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.IdentifyStoreItem.ID) - return _internal_id(); -} -inline void IdentifyStoreItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.IdentifyStoreItem.ID) -} -inline ::uint32_t IdentifyStoreItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void IdentifyStoreItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// DisarmTrap - -// uint32 index = 1; -inline void DisarmTrap::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t DisarmTrap::index() const { - // @@protoc_insertion_point(field_get:dapi.commands.DisarmTrap.index) - return _internal_index(); -} -inline void DisarmTrap::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.commands.DisarmTrap.index) -} -inline ::uint32_t DisarmTrap::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void DisarmTrap::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// ------------------------------------------------------------------- - -// SkillRepair - -// uint32 ID = 1; -inline void SkillRepair::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t SkillRepair::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.SkillRepair.ID) - return _internal_id(); -} -inline void SkillRepair::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.SkillRepair.ID) -} -inline ::uint32_t SkillRepair::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void SkillRepair::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// SkillRecharge - -// uint32 ID = 1; -inline void SkillRecharge::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t SkillRecharge::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.SkillRecharge.ID) - return _internal_id(); -} -inline void SkillRecharge::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.SkillRecharge.ID) -} -inline ::uint32_t SkillRecharge::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void SkillRecharge::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// ToggleMenu - -// ------------------------------------------------------------------- - -// SaveGame - -// ------------------------------------------------------------------- - -// Quit - -// ------------------------------------------------------------------- - -// ClearCursor - -// ------------------------------------------------------------------- - -// IdentifyItem - -// uint32 ID = 1; -inline void IdentifyItem::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t IdentifyItem::id() const { - // @@protoc_insertion_point(field_get:dapi.commands.IdentifyItem.ID) - return _internal_id(); -} -inline void IdentifyItem::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.commands.IdentifyItem.ID) -} -inline ::uint32_t IdentifyItem::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void IdentifyItem::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// ------------------------------------------------------------------- - -// Command - -// .dapi.commands.Move move = 1; -inline bool Command::has_move() const { - return command_case() == kMove; -} -inline bool Command::_internal_has_move() const { - return command_case() == kMove; -} -inline void Command::set_has_move() { - _impl_._oneof_case_[0] = kMove; -} -inline void Command::clear_move() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kMove) { - if (GetArena() == nullptr) { - delete _impl_.command_.move_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.move_ != nullptr) { - _impl_.command_.move_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::Move* Command::release_move() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.move) - if (command_case() == kMove) { - clear_has_command(); - auto* temp = _impl_.command_.move_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.move_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::Move& Command::_internal_move() const { - return command_case() == kMove ? *_impl_.command_.move_ : reinterpret_cast<::dapi::commands::Move&>(::dapi::commands::_Move_default_instance_); -} -inline const ::dapi::commands::Move& Command::move() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.move) - return _internal_move(); -} -inline ::dapi::commands::Move* Command::unsafe_arena_release_move() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.move) - if (command_case() == kMove) { - clear_has_command(); - auto* temp = _impl_.command_.move_; - _impl_.command_.move_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_move(::dapi::commands::Move* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_move(); - _impl_.command_.move_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.move) -} -inline ::dapi::commands::Move* Command::_internal_mutable_move() { - if (command_case() != kMove) { - clear_command(); - set_has_move(); - _impl_.command_.move_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Move>(GetArena()); - } - return _impl_.command_.move_; -} -inline ::dapi::commands::Move* Command::mutable_move() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::Move* _msg = _internal_mutable_move(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.move) - return _msg; -} - -// .dapi.commands.Talk talk = 2; -inline bool Command::has_talk() const { - return command_case() == kTalk; -} -inline bool Command::_internal_has_talk() const { - return command_case() == kTalk; -} -inline void Command::set_has_talk() { - _impl_._oneof_case_[0] = kTalk; -} -inline void Command::clear_talk() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kTalk) { - if (GetArena() == nullptr) { - delete _impl_.command_.talk_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.talk_ != nullptr) { - _impl_.command_.talk_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::Talk* Command::release_talk() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.talk) - if (command_case() == kTalk) { - clear_has_command(); - auto* temp = _impl_.command_.talk_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.talk_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::Talk& Command::_internal_talk() const { - return command_case() == kTalk ? *_impl_.command_.talk_ : reinterpret_cast<::dapi::commands::Talk&>(::dapi::commands::_Talk_default_instance_); -} -inline const ::dapi::commands::Talk& Command::talk() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.talk) - return _internal_talk(); -} -inline ::dapi::commands::Talk* Command::unsafe_arena_release_talk() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.talk) - if (command_case() == kTalk) { - clear_has_command(); - auto* temp = _impl_.command_.talk_; - _impl_.command_.talk_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_talk(::dapi::commands::Talk* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_talk(); - _impl_.command_.talk_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.talk) -} -inline ::dapi::commands::Talk* Command::_internal_mutable_talk() { - if (command_case() != kTalk) { - clear_command(); - set_has_talk(); - _impl_.command_.talk_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Talk>(GetArena()); - } - return _impl_.command_.talk_; -} -inline ::dapi::commands::Talk* Command::mutable_talk() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::Talk* _msg = _internal_mutable_talk(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.talk) - return _msg; -} - -// .dapi.commands.SelectStoreOption option = 3; -inline bool Command::has_option() const { - return command_case() == kOption; -} -inline bool Command::_internal_has_option() const { - return command_case() == kOption; -} -inline void Command::set_has_option() { - _impl_._oneof_case_[0] = kOption; -} -inline void Command::clear_option() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kOption) { - if (GetArena() == nullptr) { - delete _impl_.command_.option_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.option_ != nullptr) { - _impl_.command_.option_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SelectStoreOption* Command::release_option() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.option) - if (command_case() == kOption) { - clear_has_command(); - auto* temp = _impl_.command_.option_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.option_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SelectStoreOption& Command::_internal_option() const { - return command_case() == kOption ? *_impl_.command_.option_ : reinterpret_cast<::dapi::commands::SelectStoreOption&>(::dapi::commands::_SelectStoreOption_default_instance_); -} -inline const ::dapi::commands::SelectStoreOption& Command::option() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.option) - return _internal_option(); -} -inline ::dapi::commands::SelectStoreOption* Command::unsafe_arena_release_option() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.option) - if (command_case() == kOption) { - clear_has_command(); - auto* temp = _impl_.command_.option_; - _impl_.command_.option_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_option(::dapi::commands::SelectStoreOption* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_option(); - _impl_.command_.option_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.option) -} -inline ::dapi::commands::SelectStoreOption* Command::_internal_mutable_option() { - if (command_case() != kOption) { - clear_command(); - set_has_option(); - _impl_.command_.option_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SelectStoreOption>(GetArena()); - } - return _impl_.command_.option_; -} -inline ::dapi::commands::SelectStoreOption* Command::mutable_option() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SelectStoreOption* _msg = _internal_mutable_option(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.option) - return _msg; -} - -// .dapi.commands.BuyItem buyItem = 4; -inline bool Command::has_buyitem() const { - return command_case() == kBuyItem; -} -inline bool Command::_internal_has_buyitem() const { - return command_case() == kBuyItem; -} -inline void Command::set_has_buyitem() { - _impl_._oneof_case_[0] = kBuyItem; -} -inline void Command::clear_buyitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kBuyItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.buyitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.buyitem_ != nullptr) { - _impl_.command_.buyitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::BuyItem* Command::release_buyitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.buyItem) - if (command_case() == kBuyItem) { - clear_has_command(); - auto* temp = _impl_.command_.buyitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.buyitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::BuyItem& Command::_internal_buyitem() const { - return command_case() == kBuyItem ? *_impl_.command_.buyitem_ : reinterpret_cast<::dapi::commands::BuyItem&>(::dapi::commands::_BuyItem_default_instance_); -} -inline const ::dapi::commands::BuyItem& Command::buyitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.buyItem) - return _internal_buyitem(); -} -inline ::dapi::commands::BuyItem* Command::unsafe_arena_release_buyitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.buyItem) - if (command_case() == kBuyItem) { - clear_has_command(); - auto* temp = _impl_.command_.buyitem_; - _impl_.command_.buyitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_buyitem(::dapi::commands::BuyItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_buyitem(); - _impl_.command_.buyitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.buyItem) -} -inline ::dapi::commands::BuyItem* Command::_internal_mutable_buyitem() { - if (command_case() != kBuyItem) { - clear_command(); - set_has_buyitem(); - _impl_.command_.buyitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::BuyItem>(GetArena()); - } - return _impl_.command_.buyitem_; -} -inline ::dapi::commands::BuyItem* Command::mutable_buyitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::BuyItem* _msg = _internal_mutable_buyitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.buyItem) - return _msg; -} - -// .dapi.commands.SellItem sellItem = 5; -inline bool Command::has_sellitem() const { - return command_case() == kSellItem; -} -inline bool Command::_internal_has_sellitem() const { - return command_case() == kSellItem; -} -inline void Command::set_has_sellitem() { - _impl_._oneof_case_[0] = kSellItem; -} -inline void Command::clear_sellitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSellItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.sellitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.sellitem_ != nullptr) { - _impl_.command_.sellitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SellItem* Command::release_sellitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.sellItem) - if (command_case() == kSellItem) { - clear_has_command(); - auto* temp = _impl_.command_.sellitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.sellitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SellItem& Command::_internal_sellitem() const { - return command_case() == kSellItem ? *_impl_.command_.sellitem_ : reinterpret_cast<::dapi::commands::SellItem&>(::dapi::commands::_SellItem_default_instance_); -} -inline const ::dapi::commands::SellItem& Command::sellitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.sellItem) - return _internal_sellitem(); -} -inline ::dapi::commands::SellItem* Command::unsafe_arena_release_sellitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.sellItem) - if (command_case() == kSellItem) { - clear_has_command(); - auto* temp = _impl_.command_.sellitem_; - _impl_.command_.sellitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_sellitem(::dapi::commands::SellItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_sellitem(); - _impl_.command_.sellitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.sellItem) -} -inline ::dapi::commands::SellItem* Command::_internal_mutable_sellitem() { - if (command_case() != kSellItem) { - clear_command(); - set_has_sellitem(); - _impl_.command_.sellitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SellItem>(GetArena()); - } - return _impl_.command_.sellitem_; -} -inline ::dapi::commands::SellItem* Command::mutable_sellitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SellItem* _msg = _internal_mutable_sellitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.sellItem) - return _msg; -} - -// .dapi.commands.RechargeItem rechargeItem = 6; -inline bool Command::has_rechargeitem() const { - return command_case() == kRechargeItem; -} -inline bool Command::_internal_has_rechargeitem() const { - return command_case() == kRechargeItem; -} -inline void Command::set_has_rechargeitem() { - _impl_._oneof_case_[0] = kRechargeItem; -} -inline void Command::clear_rechargeitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kRechargeItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.rechargeitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.rechargeitem_ != nullptr) { - _impl_.command_.rechargeitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::RechargeItem* Command::release_rechargeitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.rechargeItem) - if (command_case() == kRechargeItem) { - clear_has_command(); - auto* temp = _impl_.command_.rechargeitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.rechargeitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::RechargeItem& Command::_internal_rechargeitem() const { - return command_case() == kRechargeItem ? *_impl_.command_.rechargeitem_ : reinterpret_cast<::dapi::commands::RechargeItem&>(::dapi::commands::_RechargeItem_default_instance_); -} -inline const ::dapi::commands::RechargeItem& Command::rechargeitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.rechargeItem) - return _internal_rechargeitem(); -} -inline ::dapi::commands::RechargeItem* Command::unsafe_arena_release_rechargeitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.rechargeItem) - if (command_case() == kRechargeItem) { - clear_has_command(); - auto* temp = _impl_.command_.rechargeitem_; - _impl_.command_.rechargeitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_rechargeitem(::dapi::commands::RechargeItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_rechargeitem(); - _impl_.command_.rechargeitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.rechargeItem) -} -inline ::dapi::commands::RechargeItem* Command::_internal_mutable_rechargeitem() { - if (command_case() != kRechargeItem) { - clear_command(); - set_has_rechargeitem(); - _impl_.command_.rechargeitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::RechargeItem>(GetArena()); - } - return _impl_.command_.rechargeitem_; -} -inline ::dapi::commands::RechargeItem* Command::mutable_rechargeitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::RechargeItem* _msg = _internal_mutable_rechargeitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.rechargeItem) - return _msg; -} - -// .dapi.commands.RepairItem repairItem = 7; -inline bool Command::has_repairitem() const { - return command_case() == kRepairItem; -} -inline bool Command::_internal_has_repairitem() const { - return command_case() == kRepairItem; -} -inline void Command::set_has_repairitem() { - _impl_._oneof_case_[0] = kRepairItem; -} -inline void Command::clear_repairitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kRepairItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.repairitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.repairitem_ != nullptr) { - _impl_.command_.repairitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::RepairItem* Command::release_repairitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.repairItem) - if (command_case() == kRepairItem) { - clear_has_command(); - auto* temp = _impl_.command_.repairitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.repairitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::RepairItem& Command::_internal_repairitem() const { - return command_case() == kRepairItem ? *_impl_.command_.repairitem_ : reinterpret_cast<::dapi::commands::RepairItem&>(::dapi::commands::_RepairItem_default_instance_); -} -inline const ::dapi::commands::RepairItem& Command::repairitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.repairItem) - return _internal_repairitem(); -} -inline ::dapi::commands::RepairItem* Command::unsafe_arena_release_repairitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.repairItem) - if (command_case() == kRepairItem) { - clear_has_command(); - auto* temp = _impl_.command_.repairitem_; - _impl_.command_.repairitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_repairitem(::dapi::commands::RepairItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_repairitem(); - _impl_.command_.repairitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.repairItem) -} -inline ::dapi::commands::RepairItem* Command::_internal_mutable_repairitem() { - if (command_case() != kRepairItem) { - clear_command(); - set_has_repairitem(); - _impl_.command_.repairitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::RepairItem>(GetArena()); - } - return _impl_.command_.repairitem_; -} -inline ::dapi::commands::RepairItem* Command::mutable_repairitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::RepairItem* _msg = _internal_mutable_repairitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.repairItem) - return _msg; -} - -// .dapi.commands.AttackMonster attackMonster = 8; -inline bool Command::has_attackmonster() const { - return command_case() == kAttackMonster; -} -inline bool Command::_internal_has_attackmonster() const { - return command_case() == kAttackMonster; -} -inline void Command::set_has_attackmonster() { - _impl_._oneof_case_[0] = kAttackMonster; -} -inline void Command::clear_attackmonster() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kAttackMonster) { - if (GetArena() == nullptr) { - delete _impl_.command_.attackmonster_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.attackmonster_ != nullptr) { - _impl_.command_.attackmonster_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::AttackMonster* Command::release_attackmonster() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.attackMonster) - if (command_case() == kAttackMonster) { - clear_has_command(); - auto* temp = _impl_.command_.attackmonster_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.attackmonster_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::AttackMonster& Command::_internal_attackmonster() const { - return command_case() == kAttackMonster ? *_impl_.command_.attackmonster_ : reinterpret_cast<::dapi::commands::AttackMonster&>(::dapi::commands::_AttackMonster_default_instance_); -} -inline const ::dapi::commands::AttackMonster& Command::attackmonster() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.attackMonster) - return _internal_attackmonster(); -} -inline ::dapi::commands::AttackMonster* Command::unsafe_arena_release_attackmonster() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.attackMonster) - if (command_case() == kAttackMonster) { - clear_has_command(); - auto* temp = _impl_.command_.attackmonster_; - _impl_.command_.attackmonster_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_attackmonster(::dapi::commands::AttackMonster* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_attackmonster(); - _impl_.command_.attackmonster_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.attackMonster) -} -inline ::dapi::commands::AttackMonster* Command::_internal_mutable_attackmonster() { - if (command_case() != kAttackMonster) { - clear_command(); - set_has_attackmonster(); - _impl_.command_.attackmonster_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::AttackMonster>(GetArena()); - } - return _impl_.command_.attackmonster_; -} -inline ::dapi::commands::AttackMonster* Command::mutable_attackmonster() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::AttackMonster* _msg = _internal_mutable_attackmonster(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.attackMonster) - return _msg; -} - -// .dapi.commands.AttackXY attackXY = 9; -inline bool Command::has_attackxy() const { - return command_case() == kAttackXY; -} -inline bool Command::_internal_has_attackxy() const { - return command_case() == kAttackXY; -} -inline void Command::set_has_attackxy() { - _impl_._oneof_case_[0] = kAttackXY; -} -inline void Command::clear_attackxy() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kAttackXY) { - if (GetArena() == nullptr) { - delete _impl_.command_.attackxy_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.attackxy_ != nullptr) { - _impl_.command_.attackxy_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::AttackXY* Command::release_attackxy() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.attackXY) - if (command_case() == kAttackXY) { - clear_has_command(); - auto* temp = _impl_.command_.attackxy_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.attackxy_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::AttackXY& Command::_internal_attackxy() const { - return command_case() == kAttackXY ? *_impl_.command_.attackxy_ : reinterpret_cast<::dapi::commands::AttackXY&>(::dapi::commands::_AttackXY_default_instance_); -} -inline const ::dapi::commands::AttackXY& Command::attackxy() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.attackXY) - return _internal_attackxy(); -} -inline ::dapi::commands::AttackXY* Command::unsafe_arena_release_attackxy() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.attackXY) - if (command_case() == kAttackXY) { - clear_has_command(); - auto* temp = _impl_.command_.attackxy_; - _impl_.command_.attackxy_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_attackxy(::dapi::commands::AttackXY* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_attackxy(); - _impl_.command_.attackxy_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.attackXY) -} -inline ::dapi::commands::AttackXY* Command::_internal_mutable_attackxy() { - if (command_case() != kAttackXY) { - clear_command(); - set_has_attackxy(); - _impl_.command_.attackxy_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::AttackXY>(GetArena()); - } - return _impl_.command_.attackxy_; -} -inline ::dapi::commands::AttackXY* Command::mutable_attackxy() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::AttackXY* _msg = _internal_mutable_attackxy(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.attackXY) - return _msg; -} - -// .dapi.commands.OperateObject operateObject = 10; -inline bool Command::has_operateobject() const { - return command_case() == kOperateObject; -} -inline bool Command::_internal_has_operateobject() const { - return command_case() == kOperateObject; -} -inline void Command::set_has_operateobject() { - _impl_._oneof_case_[0] = kOperateObject; -} -inline void Command::clear_operateobject() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kOperateObject) { - if (GetArena() == nullptr) { - delete _impl_.command_.operateobject_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.operateobject_ != nullptr) { - _impl_.command_.operateobject_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::OperateObject* Command::release_operateobject() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.operateObject) - if (command_case() == kOperateObject) { - clear_has_command(); - auto* temp = _impl_.command_.operateobject_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.operateobject_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::OperateObject& Command::_internal_operateobject() const { - return command_case() == kOperateObject ? *_impl_.command_.operateobject_ : reinterpret_cast<::dapi::commands::OperateObject&>(::dapi::commands::_OperateObject_default_instance_); -} -inline const ::dapi::commands::OperateObject& Command::operateobject() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.operateObject) - return _internal_operateobject(); -} -inline ::dapi::commands::OperateObject* Command::unsafe_arena_release_operateobject() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.operateObject) - if (command_case() == kOperateObject) { - clear_has_command(); - auto* temp = _impl_.command_.operateobject_; - _impl_.command_.operateobject_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_operateobject(::dapi::commands::OperateObject* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_operateobject(); - _impl_.command_.operateobject_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.operateObject) -} -inline ::dapi::commands::OperateObject* Command::_internal_mutable_operateobject() { - if (command_case() != kOperateObject) { - clear_command(); - set_has_operateobject(); - _impl_.command_.operateobject_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::OperateObject>(GetArena()); - } - return _impl_.command_.operateobject_; -} -inline ::dapi::commands::OperateObject* Command::mutable_operateobject() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::OperateObject* _msg = _internal_mutable_operateobject(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.operateObject) - return _msg; -} - -// .dapi.commands.UseBeltItem useBeltItem = 11; -inline bool Command::has_usebeltitem() const { - return command_case() == kUseBeltItem; -} -inline bool Command::_internal_has_usebeltitem() const { - return command_case() == kUseBeltItem; -} -inline void Command::set_has_usebeltitem() { - _impl_._oneof_case_[0] = kUseBeltItem; -} -inline void Command::clear_usebeltitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kUseBeltItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.usebeltitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.usebeltitem_ != nullptr) { - _impl_.command_.usebeltitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::UseBeltItem* Command::release_usebeltitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.useBeltItem) - if (command_case() == kUseBeltItem) { - clear_has_command(); - auto* temp = _impl_.command_.usebeltitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.usebeltitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::UseBeltItem& Command::_internal_usebeltitem() const { - return command_case() == kUseBeltItem ? *_impl_.command_.usebeltitem_ : reinterpret_cast<::dapi::commands::UseBeltItem&>(::dapi::commands::_UseBeltItem_default_instance_); -} -inline const ::dapi::commands::UseBeltItem& Command::usebeltitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.useBeltItem) - return _internal_usebeltitem(); -} -inline ::dapi::commands::UseBeltItem* Command::unsafe_arena_release_usebeltitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.useBeltItem) - if (command_case() == kUseBeltItem) { - clear_has_command(); - auto* temp = _impl_.command_.usebeltitem_; - _impl_.command_.usebeltitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_usebeltitem(::dapi::commands::UseBeltItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_usebeltitem(); - _impl_.command_.usebeltitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.useBeltItem) -} -inline ::dapi::commands::UseBeltItem* Command::_internal_mutable_usebeltitem() { - if (command_case() != kUseBeltItem) { - clear_command(); - set_has_usebeltitem(); - _impl_.command_.usebeltitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::UseBeltItem>(GetArena()); - } - return _impl_.command_.usebeltitem_; -} -inline ::dapi::commands::UseBeltItem* Command::mutable_usebeltitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::UseBeltItem* _msg = _internal_mutable_usebeltitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.useBeltItem) - return _msg; -} - -// .dapi.commands.ToggleCharacterSheet toggleCharacterSheet = 12; -inline bool Command::has_togglecharactersheet() const { - return command_case() == kToggleCharacterSheet; -} -inline bool Command::_internal_has_togglecharactersheet() const { - return command_case() == kToggleCharacterSheet; -} -inline void Command::set_has_togglecharactersheet() { - _impl_._oneof_case_[0] = kToggleCharacterSheet; -} -inline void Command::clear_togglecharactersheet() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kToggleCharacterSheet) { - if (GetArena() == nullptr) { - delete _impl_.command_.togglecharactersheet_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.togglecharactersheet_ != nullptr) { - _impl_.command_.togglecharactersheet_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::ToggleCharacterSheet* Command::release_togglecharactersheet() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleCharacterSheet) - if (command_case() == kToggleCharacterSheet) { - clear_has_command(); - auto* temp = _impl_.command_.togglecharactersheet_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.togglecharactersheet_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::ToggleCharacterSheet& Command::_internal_togglecharactersheet() const { - return command_case() == kToggleCharacterSheet ? *_impl_.command_.togglecharactersheet_ : reinterpret_cast<::dapi::commands::ToggleCharacterSheet&>(::dapi::commands::_ToggleCharacterSheet_default_instance_); -} -inline const ::dapi::commands::ToggleCharacterSheet& Command::togglecharactersheet() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleCharacterSheet) - return _internal_togglecharactersheet(); -} -inline ::dapi::commands::ToggleCharacterSheet* Command::unsafe_arena_release_togglecharactersheet() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleCharacterSheet) - if (command_case() == kToggleCharacterSheet) { - clear_has_command(); - auto* temp = _impl_.command_.togglecharactersheet_; - _impl_.command_.togglecharactersheet_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_togglecharactersheet(::dapi::commands::ToggleCharacterSheet* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_togglecharactersheet(); - _impl_.command_.togglecharactersheet_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleCharacterSheet) -} -inline ::dapi::commands::ToggleCharacterSheet* Command::_internal_mutable_togglecharactersheet() { - if (command_case() != kToggleCharacterSheet) { - clear_command(); - set_has_togglecharactersheet(); - _impl_.command_.togglecharactersheet_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleCharacterSheet>(GetArena()); - } - return _impl_.command_.togglecharactersheet_; -} -inline ::dapi::commands::ToggleCharacterSheet* Command::mutable_togglecharactersheet() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::ToggleCharacterSheet* _msg = _internal_mutable_togglecharactersheet(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleCharacterSheet) - return _msg; -} - -// .dapi.commands.IncreaseStat increaseStat = 13; -inline bool Command::has_increasestat() const { - return command_case() == kIncreaseStat; -} -inline bool Command::_internal_has_increasestat() const { - return command_case() == kIncreaseStat; -} -inline void Command::set_has_increasestat() { - _impl_._oneof_case_[0] = kIncreaseStat; -} -inline void Command::clear_increasestat() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kIncreaseStat) { - if (GetArena() == nullptr) { - delete _impl_.command_.increasestat_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.increasestat_ != nullptr) { - _impl_.command_.increasestat_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::IncreaseStat* Command::release_increasestat() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.increaseStat) - if (command_case() == kIncreaseStat) { - clear_has_command(); - auto* temp = _impl_.command_.increasestat_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.increasestat_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::IncreaseStat& Command::_internal_increasestat() const { - return command_case() == kIncreaseStat ? *_impl_.command_.increasestat_ : reinterpret_cast<::dapi::commands::IncreaseStat&>(::dapi::commands::_IncreaseStat_default_instance_); -} -inline const ::dapi::commands::IncreaseStat& Command::increasestat() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.increaseStat) - return _internal_increasestat(); -} -inline ::dapi::commands::IncreaseStat* Command::unsafe_arena_release_increasestat() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.increaseStat) - if (command_case() == kIncreaseStat) { - clear_has_command(); - auto* temp = _impl_.command_.increasestat_; - _impl_.command_.increasestat_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_increasestat(::dapi::commands::IncreaseStat* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_increasestat(); - _impl_.command_.increasestat_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.increaseStat) -} -inline ::dapi::commands::IncreaseStat* Command::_internal_mutable_increasestat() { - if (command_case() != kIncreaseStat) { - clear_command(); - set_has_increasestat(); - _impl_.command_.increasestat_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IncreaseStat>(GetArena()); - } - return _impl_.command_.increasestat_; -} -inline ::dapi::commands::IncreaseStat* Command::mutable_increasestat() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::IncreaseStat* _msg = _internal_mutable_increasestat(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.increaseStat) - return _msg; -} - -// .dapi.commands.GetItem getItem = 14; -inline bool Command::has_getitem() const { - return command_case() == kGetItem; -} -inline bool Command::_internal_has_getitem() const { - return command_case() == kGetItem; -} -inline void Command::set_has_getitem() { - _impl_._oneof_case_[0] = kGetItem; -} -inline void Command::clear_getitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kGetItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.getitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.getitem_ != nullptr) { - _impl_.command_.getitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::GetItem* Command::release_getitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.getItem) - if (command_case() == kGetItem) { - clear_has_command(); - auto* temp = _impl_.command_.getitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.getitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::GetItem& Command::_internal_getitem() const { - return command_case() == kGetItem ? *_impl_.command_.getitem_ : reinterpret_cast<::dapi::commands::GetItem&>(::dapi::commands::_GetItem_default_instance_); -} -inline const ::dapi::commands::GetItem& Command::getitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.getItem) - return _internal_getitem(); -} -inline ::dapi::commands::GetItem* Command::unsafe_arena_release_getitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.getItem) - if (command_case() == kGetItem) { - clear_has_command(); - auto* temp = _impl_.command_.getitem_; - _impl_.command_.getitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_getitem(::dapi::commands::GetItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_getitem(); - _impl_.command_.getitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.getItem) -} -inline ::dapi::commands::GetItem* Command::_internal_mutable_getitem() { - if (command_case() != kGetItem) { - clear_command(); - set_has_getitem(); - _impl_.command_.getitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::GetItem>(GetArena()); - } - return _impl_.command_.getitem_; -} -inline ::dapi::commands::GetItem* Command::mutable_getitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::GetItem* _msg = _internal_mutable_getitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.getItem) - return _msg; -} - -// .dapi.commands.SetSpell setSpell = 15; -inline bool Command::has_setspell() const { - return command_case() == kSetSpell; -} -inline bool Command::_internal_has_setspell() const { - return command_case() == kSetSpell; -} -inline void Command::set_has_setspell() { - _impl_._oneof_case_[0] = kSetSpell; -} -inline void Command::clear_setspell() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSetSpell) { - if (GetArena() == nullptr) { - delete _impl_.command_.setspell_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.setspell_ != nullptr) { - _impl_.command_.setspell_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SetSpell* Command::release_setspell() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.setSpell) - if (command_case() == kSetSpell) { - clear_has_command(); - auto* temp = _impl_.command_.setspell_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.setspell_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SetSpell& Command::_internal_setspell() const { - return command_case() == kSetSpell ? *_impl_.command_.setspell_ : reinterpret_cast<::dapi::commands::SetSpell&>(::dapi::commands::_SetSpell_default_instance_); -} -inline const ::dapi::commands::SetSpell& Command::setspell() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.setSpell) - return _internal_setspell(); -} -inline ::dapi::commands::SetSpell* Command::unsafe_arena_release_setspell() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.setSpell) - if (command_case() == kSetSpell) { - clear_has_command(); - auto* temp = _impl_.command_.setspell_; - _impl_.command_.setspell_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_setspell(::dapi::commands::SetSpell* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_setspell(); - _impl_.command_.setspell_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.setSpell) -} -inline ::dapi::commands::SetSpell* Command::_internal_mutable_setspell() { - if (command_case() != kSetSpell) { - clear_command(); - set_has_setspell(); - _impl_.command_.setspell_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SetSpell>(GetArena()); - } - return _impl_.command_.setspell_; -} -inline ::dapi::commands::SetSpell* Command::mutable_setspell() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SetSpell* _msg = _internal_mutable_setspell(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.setSpell) - return _msg; -} - -// .dapi.commands.CastMonster castMonster = 16; -inline bool Command::has_castmonster() const { - return command_case() == kCastMonster; -} -inline bool Command::_internal_has_castmonster() const { - return command_case() == kCastMonster; -} -inline void Command::set_has_castmonster() { - _impl_._oneof_case_[0] = kCastMonster; -} -inline void Command::clear_castmonster() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kCastMonster) { - if (GetArena() == nullptr) { - delete _impl_.command_.castmonster_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.castmonster_ != nullptr) { - _impl_.command_.castmonster_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::CastMonster* Command::release_castmonster() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.castMonster) - if (command_case() == kCastMonster) { - clear_has_command(); - auto* temp = _impl_.command_.castmonster_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.castmonster_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::CastMonster& Command::_internal_castmonster() const { - return command_case() == kCastMonster ? *_impl_.command_.castmonster_ : reinterpret_cast<::dapi::commands::CastMonster&>(::dapi::commands::_CastMonster_default_instance_); -} -inline const ::dapi::commands::CastMonster& Command::castmonster() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.castMonster) - return _internal_castmonster(); -} -inline ::dapi::commands::CastMonster* Command::unsafe_arena_release_castmonster() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.castMonster) - if (command_case() == kCastMonster) { - clear_has_command(); - auto* temp = _impl_.command_.castmonster_; - _impl_.command_.castmonster_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_castmonster(::dapi::commands::CastMonster* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_castmonster(); - _impl_.command_.castmonster_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.castMonster) -} -inline ::dapi::commands::CastMonster* Command::_internal_mutable_castmonster() { - if (command_case() != kCastMonster) { - clear_command(); - set_has_castmonster(); - _impl_.command_.castmonster_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CastMonster>(GetArena()); - } - return _impl_.command_.castmonster_; -} -inline ::dapi::commands::CastMonster* Command::mutable_castmonster() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::CastMonster* _msg = _internal_mutable_castmonster(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.castMonster) - return _msg; -} - -// .dapi.commands.CastXY castXY = 17; -inline bool Command::has_castxy() const { - return command_case() == kCastXY; -} -inline bool Command::_internal_has_castxy() const { - return command_case() == kCastXY; -} -inline void Command::set_has_castxy() { - _impl_._oneof_case_[0] = kCastXY; -} -inline void Command::clear_castxy() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kCastXY) { - if (GetArena() == nullptr) { - delete _impl_.command_.castxy_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.castxy_ != nullptr) { - _impl_.command_.castxy_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::CastXY* Command::release_castxy() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.castXY) - if (command_case() == kCastXY) { - clear_has_command(); - auto* temp = _impl_.command_.castxy_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.castxy_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::CastXY& Command::_internal_castxy() const { - return command_case() == kCastXY ? *_impl_.command_.castxy_ : reinterpret_cast<::dapi::commands::CastXY&>(::dapi::commands::_CastXY_default_instance_); -} -inline const ::dapi::commands::CastXY& Command::castxy() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.castXY) - return _internal_castxy(); -} -inline ::dapi::commands::CastXY* Command::unsafe_arena_release_castxy() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.castXY) - if (command_case() == kCastXY) { - clear_has_command(); - auto* temp = _impl_.command_.castxy_; - _impl_.command_.castxy_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_castxy(::dapi::commands::CastXY* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_castxy(); - _impl_.command_.castxy_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.castXY) -} -inline ::dapi::commands::CastXY* Command::_internal_mutable_castxy() { - if (command_case() != kCastXY) { - clear_command(); - set_has_castxy(); - _impl_.command_.castxy_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CastXY>(GetArena()); - } - return _impl_.command_.castxy_; -} -inline ::dapi::commands::CastXY* Command::mutable_castxy() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::CastXY* _msg = _internal_mutable_castxy(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.castXY) - return _msg; -} - -// .dapi.commands.ToggleInventory toggleInventory = 18; -inline bool Command::has_toggleinventory() const { - return command_case() == kToggleInventory; -} -inline bool Command::_internal_has_toggleinventory() const { - return command_case() == kToggleInventory; -} -inline void Command::set_has_toggleinventory() { - _impl_._oneof_case_[0] = kToggleInventory; -} -inline void Command::clear_toggleinventory() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kToggleInventory) { - if (GetArena() == nullptr) { - delete _impl_.command_.toggleinventory_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.toggleinventory_ != nullptr) { - _impl_.command_.toggleinventory_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::ToggleInventory* Command::release_toggleinventory() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleInventory) - if (command_case() == kToggleInventory) { - clear_has_command(); - auto* temp = _impl_.command_.toggleinventory_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.toggleinventory_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::ToggleInventory& Command::_internal_toggleinventory() const { - return command_case() == kToggleInventory ? *_impl_.command_.toggleinventory_ : reinterpret_cast<::dapi::commands::ToggleInventory&>(::dapi::commands::_ToggleInventory_default_instance_); -} -inline const ::dapi::commands::ToggleInventory& Command::toggleinventory() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleInventory) - return _internal_toggleinventory(); -} -inline ::dapi::commands::ToggleInventory* Command::unsafe_arena_release_toggleinventory() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleInventory) - if (command_case() == kToggleInventory) { - clear_has_command(); - auto* temp = _impl_.command_.toggleinventory_; - _impl_.command_.toggleinventory_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_toggleinventory(::dapi::commands::ToggleInventory* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_toggleinventory(); - _impl_.command_.toggleinventory_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleInventory) -} -inline ::dapi::commands::ToggleInventory* Command::_internal_mutable_toggleinventory() { - if (command_case() != kToggleInventory) { - clear_command(); - set_has_toggleinventory(); - _impl_.command_.toggleinventory_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleInventory>(GetArena()); - } - return _impl_.command_.toggleinventory_; -} -inline ::dapi::commands::ToggleInventory* Command::mutable_toggleinventory() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::ToggleInventory* _msg = _internal_mutable_toggleinventory(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleInventory) - return _msg; -} - -// .dapi.commands.PutInCursor putInCursor = 19; -inline bool Command::has_putincursor() const { - return command_case() == kPutInCursor; -} -inline bool Command::_internal_has_putincursor() const { - return command_case() == kPutInCursor; -} -inline void Command::set_has_putincursor() { - _impl_._oneof_case_[0] = kPutInCursor; -} -inline void Command::clear_putincursor() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kPutInCursor) { - if (GetArena() == nullptr) { - delete _impl_.command_.putincursor_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.putincursor_ != nullptr) { - _impl_.command_.putincursor_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::PutInCursor* Command::release_putincursor() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.putInCursor) - if (command_case() == kPutInCursor) { - clear_has_command(); - auto* temp = _impl_.command_.putincursor_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.putincursor_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::PutInCursor& Command::_internal_putincursor() const { - return command_case() == kPutInCursor ? *_impl_.command_.putincursor_ : reinterpret_cast<::dapi::commands::PutInCursor&>(::dapi::commands::_PutInCursor_default_instance_); -} -inline const ::dapi::commands::PutInCursor& Command::putincursor() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.putInCursor) - return _internal_putincursor(); -} -inline ::dapi::commands::PutInCursor* Command::unsafe_arena_release_putincursor() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.putInCursor) - if (command_case() == kPutInCursor) { - clear_has_command(); - auto* temp = _impl_.command_.putincursor_; - _impl_.command_.putincursor_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_putincursor(::dapi::commands::PutInCursor* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_putincursor(); - _impl_.command_.putincursor_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.putInCursor) -} -inline ::dapi::commands::PutInCursor* Command::_internal_mutable_putincursor() { - if (command_case() != kPutInCursor) { - clear_command(); - set_has_putincursor(); - _impl_.command_.putincursor_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::PutInCursor>(GetArena()); - } - return _impl_.command_.putincursor_; -} -inline ::dapi::commands::PutInCursor* Command::mutable_putincursor() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::PutInCursor* _msg = _internal_mutable_putincursor(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.putInCursor) - return _msg; -} - -// .dapi.commands.PutCursorItem putCursorItem = 20; -inline bool Command::has_putcursoritem() const { - return command_case() == kPutCursorItem; -} -inline bool Command::_internal_has_putcursoritem() const { - return command_case() == kPutCursorItem; -} -inline void Command::set_has_putcursoritem() { - _impl_._oneof_case_[0] = kPutCursorItem; -} -inline void Command::clear_putcursoritem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kPutCursorItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.putcursoritem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.putcursoritem_ != nullptr) { - _impl_.command_.putcursoritem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::PutCursorItem* Command::release_putcursoritem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.putCursorItem) - if (command_case() == kPutCursorItem) { - clear_has_command(); - auto* temp = _impl_.command_.putcursoritem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.putcursoritem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::PutCursorItem& Command::_internal_putcursoritem() const { - return command_case() == kPutCursorItem ? *_impl_.command_.putcursoritem_ : reinterpret_cast<::dapi::commands::PutCursorItem&>(::dapi::commands::_PutCursorItem_default_instance_); -} -inline const ::dapi::commands::PutCursorItem& Command::putcursoritem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.putCursorItem) - return _internal_putcursoritem(); -} -inline ::dapi::commands::PutCursorItem* Command::unsafe_arena_release_putcursoritem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.putCursorItem) - if (command_case() == kPutCursorItem) { - clear_has_command(); - auto* temp = _impl_.command_.putcursoritem_; - _impl_.command_.putcursoritem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_putcursoritem(::dapi::commands::PutCursorItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_putcursoritem(); - _impl_.command_.putcursoritem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.putCursorItem) -} -inline ::dapi::commands::PutCursorItem* Command::_internal_mutable_putcursoritem() { - if (command_case() != kPutCursorItem) { - clear_command(); - set_has_putcursoritem(); - _impl_.command_.putcursoritem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::PutCursorItem>(GetArena()); - } - return _impl_.command_.putcursoritem_; -} -inline ::dapi::commands::PutCursorItem* Command::mutable_putcursoritem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::PutCursorItem* _msg = _internal_mutable_putcursoritem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.putCursorItem) - return _msg; -} - -// .dapi.commands.DropCursorItem dropCursorItem = 21; -inline bool Command::has_dropcursoritem() const { - return command_case() == kDropCursorItem; -} -inline bool Command::_internal_has_dropcursoritem() const { - return command_case() == kDropCursorItem; -} -inline void Command::set_has_dropcursoritem() { - _impl_._oneof_case_[0] = kDropCursorItem; -} -inline void Command::clear_dropcursoritem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kDropCursorItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.dropcursoritem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.dropcursoritem_ != nullptr) { - _impl_.command_.dropcursoritem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::DropCursorItem* Command::release_dropcursoritem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.dropCursorItem) - if (command_case() == kDropCursorItem) { - clear_has_command(); - auto* temp = _impl_.command_.dropcursoritem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.dropcursoritem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::DropCursorItem& Command::_internal_dropcursoritem() const { - return command_case() == kDropCursorItem ? *_impl_.command_.dropcursoritem_ : reinterpret_cast<::dapi::commands::DropCursorItem&>(::dapi::commands::_DropCursorItem_default_instance_); -} -inline const ::dapi::commands::DropCursorItem& Command::dropcursoritem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.dropCursorItem) - return _internal_dropcursoritem(); -} -inline ::dapi::commands::DropCursorItem* Command::unsafe_arena_release_dropcursoritem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.dropCursorItem) - if (command_case() == kDropCursorItem) { - clear_has_command(); - auto* temp = _impl_.command_.dropcursoritem_; - _impl_.command_.dropcursoritem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_dropcursoritem(::dapi::commands::DropCursorItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_dropcursoritem(); - _impl_.command_.dropcursoritem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.dropCursorItem) -} -inline ::dapi::commands::DropCursorItem* Command::_internal_mutable_dropcursoritem() { - if (command_case() != kDropCursorItem) { - clear_command(); - set_has_dropcursoritem(); - _impl_.command_.dropcursoritem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::DropCursorItem>(GetArena()); - } - return _impl_.command_.dropcursoritem_; -} -inline ::dapi::commands::DropCursorItem* Command::mutable_dropcursoritem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::DropCursorItem* _msg = _internal_mutable_dropcursoritem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.dropCursorItem) - return _msg; -} - -// .dapi.commands.UseItem useItem = 22; -inline bool Command::has_useitem() const { - return command_case() == kUseItem; -} -inline bool Command::_internal_has_useitem() const { - return command_case() == kUseItem; -} -inline void Command::set_has_useitem() { - _impl_._oneof_case_[0] = kUseItem; -} -inline void Command::clear_useitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kUseItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.useitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.useitem_ != nullptr) { - _impl_.command_.useitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::UseItem* Command::release_useitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.useItem) - if (command_case() == kUseItem) { - clear_has_command(); - auto* temp = _impl_.command_.useitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.useitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::UseItem& Command::_internal_useitem() const { - return command_case() == kUseItem ? *_impl_.command_.useitem_ : reinterpret_cast<::dapi::commands::UseItem&>(::dapi::commands::_UseItem_default_instance_); -} -inline const ::dapi::commands::UseItem& Command::useitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.useItem) - return _internal_useitem(); -} -inline ::dapi::commands::UseItem* Command::unsafe_arena_release_useitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.useItem) - if (command_case() == kUseItem) { - clear_has_command(); - auto* temp = _impl_.command_.useitem_; - _impl_.command_.useitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_useitem(::dapi::commands::UseItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_useitem(); - _impl_.command_.useitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.useItem) -} -inline ::dapi::commands::UseItem* Command::_internal_mutable_useitem() { - if (command_case() != kUseItem) { - clear_command(); - set_has_useitem(); - _impl_.command_.useitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::UseItem>(GetArena()); - } - return _impl_.command_.useitem_; -} -inline ::dapi::commands::UseItem* Command::mutable_useitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::UseItem* _msg = _internal_mutable_useitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.useItem) - return _msg; -} - -// .dapi.commands.IdentifyStoreItem identifyStoreItem = 23; -inline bool Command::has_identifystoreitem() const { - return command_case() == kIdentifyStoreItem; -} -inline bool Command::_internal_has_identifystoreitem() const { - return command_case() == kIdentifyStoreItem; -} -inline void Command::set_has_identifystoreitem() { - _impl_._oneof_case_[0] = kIdentifyStoreItem; -} -inline void Command::clear_identifystoreitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kIdentifyStoreItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.identifystoreitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.identifystoreitem_ != nullptr) { - _impl_.command_.identifystoreitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::IdentifyStoreItem* Command::release_identifystoreitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.identifyStoreItem) - if (command_case() == kIdentifyStoreItem) { - clear_has_command(); - auto* temp = _impl_.command_.identifystoreitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.identifystoreitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::IdentifyStoreItem& Command::_internal_identifystoreitem() const { - return command_case() == kIdentifyStoreItem ? *_impl_.command_.identifystoreitem_ : reinterpret_cast<::dapi::commands::IdentifyStoreItem&>(::dapi::commands::_IdentifyStoreItem_default_instance_); -} -inline const ::dapi::commands::IdentifyStoreItem& Command::identifystoreitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.identifyStoreItem) - return _internal_identifystoreitem(); -} -inline ::dapi::commands::IdentifyStoreItem* Command::unsafe_arena_release_identifystoreitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.identifyStoreItem) - if (command_case() == kIdentifyStoreItem) { - clear_has_command(); - auto* temp = _impl_.command_.identifystoreitem_; - _impl_.command_.identifystoreitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_identifystoreitem(::dapi::commands::IdentifyStoreItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_identifystoreitem(); - _impl_.command_.identifystoreitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.identifyStoreItem) -} -inline ::dapi::commands::IdentifyStoreItem* Command::_internal_mutable_identifystoreitem() { - if (command_case() != kIdentifyStoreItem) { - clear_command(); - set_has_identifystoreitem(); - _impl_.command_.identifystoreitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IdentifyStoreItem>(GetArena()); - } - return _impl_.command_.identifystoreitem_; -} -inline ::dapi::commands::IdentifyStoreItem* Command::mutable_identifystoreitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::IdentifyStoreItem* _msg = _internal_mutable_identifystoreitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.identifyStoreItem) - return _msg; -} - -// .dapi.commands.CancelQText cancelQText = 24; -inline bool Command::has_cancelqtext() const { - return command_case() == kCancelQText; -} -inline bool Command::_internal_has_cancelqtext() const { - return command_case() == kCancelQText; -} -inline void Command::set_has_cancelqtext() { - _impl_._oneof_case_[0] = kCancelQText; -} -inline void Command::clear_cancelqtext() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kCancelQText) { - if (GetArena() == nullptr) { - delete _impl_.command_.cancelqtext_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.cancelqtext_ != nullptr) { - _impl_.command_.cancelqtext_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::CancelQText* Command::release_cancelqtext() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.cancelQText) - if (command_case() == kCancelQText) { - clear_has_command(); - auto* temp = _impl_.command_.cancelqtext_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.cancelqtext_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::CancelQText& Command::_internal_cancelqtext() const { - return command_case() == kCancelQText ? *_impl_.command_.cancelqtext_ : reinterpret_cast<::dapi::commands::CancelQText&>(::dapi::commands::_CancelQText_default_instance_); -} -inline const ::dapi::commands::CancelQText& Command::cancelqtext() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.cancelQText) - return _internal_cancelqtext(); -} -inline ::dapi::commands::CancelQText* Command::unsafe_arena_release_cancelqtext() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.cancelQText) - if (command_case() == kCancelQText) { - clear_has_command(); - auto* temp = _impl_.command_.cancelqtext_; - _impl_.command_.cancelqtext_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_cancelqtext(::dapi::commands::CancelQText* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_cancelqtext(); - _impl_.command_.cancelqtext_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.cancelQText) -} -inline ::dapi::commands::CancelQText* Command::_internal_mutable_cancelqtext() { - if (command_case() != kCancelQText) { - clear_command(); - set_has_cancelqtext(); - _impl_.command_.cancelqtext_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::CancelQText>(GetArena()); - } - return _impl_.command_.cancelqtext_; -} -inline ::dapi::commands::CancelQText* Command::mutable_cancelqtext() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::CancelQText* _msg = _internal_mutable_cancelqtext(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.cancelQText) - return _msg; -} - -// .dapi.commands.SetFPS setFPS = 25; -inline bool Command::has_setfps() const { - return command_case() == kSetFPS; -} -inline bool Command::_internal_has_setfps() const { - return command_case() == kSetFPS; -} -inline void Command::set_has_setfps() { - _impl_._oneof_case_[0] = kSetFPS; -} -inline void Command::clear_setfps() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSetFPS) { - if (GetArena() == nullptr) { - delete _impl_.command_.setfps_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.setfps_ != nullptr) { - _impl_.command_.setfps_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SetFPS* Command::release_setfps() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.setFPS) - if (command_case() == kSetFPS) { - clear_has_command(); - auto* temp = _impl_.command_.setfps_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.setfps_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SetFPS& Command::_internal_setfps() const { - return command_case() == kSetFPS ? *_impl_.command_.setfps_ : reinterpret_cast<::dapi::commands::SetFPS&>(::dapi::commands::_SetFPS_default_instance_); -} -inline const ::dapi::commands::SetFPS& Command::setfps() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.setFPS) - return _internal_setfps(); -} -inline ::dapi::commands::SetFPS* Command::unsafe_arena_release_setfps() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.setFPS) - if (command_case() == kSetFPS) { - clear_has_command(); - auto* temp = _impl_.command_.setfps_; - _impl_.command_.setfps_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_setfps(::dapi::commands::SetFPS* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_setfps(); - _impl_.command_.setfps_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.setFPS) -} -inline ::dapi::commands::SetFPS* Command::_internal_mutable_setfps() { - if (command_case() != kSetFPS) { - clear_command(); - set_has_setfps(); - _impl_.command_.setfps_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SetFPS>(GetArena()); - } - return _impl_.command_.setfps_; -} -inline ::dapi::commands::SetFPS* Command::mutable_setfps() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SetFPS* _msg = _internal_mutable_setfps(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.setFPS) - return _msg; -} - -// .dapi.commands.DisarmTrap disarmTrap = 26; -inline bool Command::has_disarmtrap() const { - return command_case() == kDisarmTrap; -} -inline bool Command::_internal_has_disarmtrap() const { - return command_case() == kDisarmTrap; -} -inline void Command::set_has_disarmtrap() { - _impl_._oneof_case_[0] = kDisarmTrap; -} -inline void Command::clear_disarmtrap() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kDisarmTrap) { - if (GetArena() == nullptr) { - delete _impl_.command_.disarmtrap_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.disarmtrap_ != nullptr) { - _impl_.command_.disarmtrap_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::DisarmTrap* Command::release_disarmtrap() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.disarmTrap) - if (command_case() == kDisarmTrap) { - clear_has_command(); - auto* temp = _impl_.command_.disarmtrap_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.disarmtrap_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::DisarmTrap& Command::_internal_disarmtrap() const { - return command_case() == kDisarmTrap ? *_impl_.command_.disarmtrap_ : reinterpret_cast<::dapi::commands::DisarmTrap&>(::dapi::commands::_DisarmTrap_default_instance_); -} -inline const ::dapi::commands::DisarmTrap& Command::disarmtrap() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.disarmTrap) - return _internal_disarmtrap(); -} -inline ::dapi::commands::DisarmTrap* Command::unsafe_arena_release_disarmtrap() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.disarmTrap) - if (command_case() == kDisarmTrap) { - clear_has_command(); - auto* temp = _impl_.command_.disarmtrap_; - _impl_.command_.disarmtrap_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_disarmtrap(::dapi::commands::DisarmTrap* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_disarmtrap(); - _impl_.command_.disarmtrap_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.disarmTrap) -} -inline ::dapi::commands::DisarmTrap* Command::_internal_mutable_disarmtrap() { - if (command_case() != kDisarmTrap) { - clear_command(); - set_has_disarmtrap(); - _impl_.command_.disarmtrap_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::DisarmTrap>(GetArena()); - } - return _impl_.command_.disarmtrap_; -} -inline ::dapi::commands::DisarmTrap* Command::mutable_disarmtrap() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::DisarmTrap* _msg = _internal_mutable_disarmtrap(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.disarmTrap) - return _msg; -} - -// .dapi.commands.SkillRepair skillRepair = 27; -inline bool Command::has_skillrepair() const { - return command_case() == kSkillRepair; -} -inline bool Command::_internal_has_skillrepair() const { - return command_case() == kSkillRepair; -} -inline void Command::set_has_skillrepair() { - _impl_._oneof_case_[0] = kSkillRepair; -} -inline void Command::clear_skillrepair() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSkillRepair) { - if (GetArena() == nullptr) { - delete _impl_.command_.skillrepair_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.skillrepair_ != nullptr) { - _impl_.command_.skillrepair_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SkillRepair* Command::release_skillrepair() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.skillRepair) - if (command_case() == kSkillRepair) { - clear_has_command(); - auto* temp = _impl_.command_.skillrepair_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.skillrepair_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SkillRepair& Command::_internal_skillrepair() const { - return command_case() == kSkillRepair ? *_impl_.command_.skillrepair_ : reinterpret_cast<::dapi::commands::SkillRepair&>(::dapi::commands::_SkillRepair_default_instance_); -} -inline const ::dapi::commands::SkillRepair& Command::skillrepair() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.skillRepair) - return _internal_skillrepair(); -} -inline ::dapi::commands::SkillRepair* Command::unsafe_arena_release_skillrepair() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.skillRepair) - if (command_case() == kSkillRepair) { - clear_has_command(); - auto* temp = _impl_.command_.skillrepair_; - _impl_.command_.skillrepair_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_skillrepair(::dapi::commands::SkillRepair* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_skillrepair(); - _impl_.command_.skillrepair_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.skillRepair) -} -inline ::dapi::commands::SkillRepair* Command::_internal_mutable_skillrepair() { - if (command_case() != kSkillRepair) { - clear_command(); - set_has_skillrepair(); - _impl_.command_.skillrepair_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SkillRepair>(GetArena()); - } - return _impl_.command_.skillrepair_; -} -inline ::dapi::commands::SkillRepair* Command::mutable_skillrepair() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SkillRepair* _msg = _internal_mutable_skillrepair(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.skillRepair) - return _msg; -} - -// .dapi.commands.SkillRecharge skillRecharge = 28; -inline bool Command::has_skillrecharge() const { - return command_case() == kSkillRecharge; -} -inline bool Command::_internal_has_skillrecharge() const { - return command_case() == kSkillRecharge; -} -inline void Command::set_has_skillrecharge() { - _impl_._oneof_case_[0] = kSkillRecharge; -} -inline void Command::clear_skillrecharge() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSkillRecharge) { - if (GetArena() == nullptr) { - delete _impl_.command_.skillrecharge_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.skillrecharge_ != nullptr) { - _impl_.command_.skillrecharge_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SkillRecharge* Command::release_skillrecharge() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.skillRecharge) - if (command_case() == kSkillRecharge) { - clear_has_command(); - auto* temp = _impl_.command_.skillrecharge_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.skillrecharge_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SkillRecharge& Command::_internal_skillrecharge() const { - return command_case() == kSkillRecharge ? *_impl_.command_.skillrecharge_ : reinterpret_cast<::dapi::commands::SkillRecharge&>(::dapi::commands::_SkillRecharge_default_instance_); -} -inline const ::dapi::commands::SkillRecharge& Command::skillrecharge() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.skillRecharge) - return _internal_skillrecharge(); -} -inline ::dapi::commands::SkillRecharge* Command::unsafe_arena_release_skillrecharge() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.skillRecharge) - if (command_case() == kSkillRecharge) { - clear_has_command(); - auto* temp = _impl_.command_.skillrecharge_; - _impl_.command_.skillrecharge_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_skillrecharge(::dapi::commands::SkillRecharge* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_skillrecharge(); - _impl_.command_.skillrecharge_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.skillRecharge) -} -inline ::dapi::commands::SkillRecharge* Command::_internal_mutable_skillrecharge() { - if (command_case() != kSkillRecharge) { - clear_command(); - set_has_skillrecharge(); - _impl_.command_.skillrecharge_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SkillRecharge>(GetArena()); - } - return _impl_.command_.skillrecharge_; -} -inline ::dapi::commands::SkillRecharge* Command::mutable_skillrecharge() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SkillRecharge* _msg = _internal_mutable_skillrecharge(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.skillRecharge) - return _msg; -} - -// .dapi.commands.ToggleMenu toggleMenu = 29; -inline bool Command::has_togglemenu() const { - return command_case() == kToggleMenu; -} -inline bool Command::_internal_has_togglemenu() const { - return command_case() == kToggleMenu; -} -inline void Command::set_has_togglemenu() { - _impl_._oneof_case_[0] = kToggleMenu; -} -inline void Command::clear_togglemenu() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kToggleMenu) { - if (GetArena() == nullptr) { - delete _impl_.command_.togglemenu_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.togglemenu_ != nullptr) { - _impl_.command_.togglemenu_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::ToggleMenu* Command::release_togglemenu() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.toggleMenu) - if (command_case() == kToggleMenu) { - clear_has_command(); - auto* temp = _impl_.command_.togglemenu_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.togglemenu_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::ToggleMenu& Command::_internal_togglemenu() const { - return command_case() == kToggleMenu ? *_impl_.command_.togglemenu_ : reinterpret_cast<::dapi::commands::ToggleMenu&>(::dapi::commands::_ToggleMenu_default_instance_); -} -inline const ::dapi::commands::ToggleMenu& Command::togglemenu() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.toggleMenu) - return _internal_togglemenu(); -} -inline ::dapi::commands::ToggleMenu* Command::unsafe_arena_release_togglemenu() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.toggleMenu) - if (command_case() == kToggleMenu) { - clear_has_command(); - auto* temp = _impl_.command_.togglemenu_; - _impl_.command_.togglemenu_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_togglemenu(::dapi::commands::ToggleMenu* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_togglemenu(); - _impl_.command_.togglemenu_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.toggleMenu) -} -inline ::dapi::commands::ToggleMenu* Command::_internal_mutable_togglemenu() { - if (command_case() != kToggleMenu) { - clear_command(); - set_has_togglemenu(); - _impl_.command_.togglemenu_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ToggleMenu>(GetArena()); - } - return _impl_.command_.togglemenu_; -} -inline ::dapi::commands::ToggleMenu* Command::mutable_togglemenu() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::ToggleMenu* _msg = _internal_mutable_togglemenu(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.toggleMenu) - return _msg; -} - -// .dapi.commands.SaveGame saveGame = 30; -inline bool Command::has_savegame() const { - return command_case() == kSaveGame; -} -inline bool Command::_internal_has_savegame() const { - return command_case() == kSaveGame; -} -inline void Command::set_has_savegame() { - _impl_._oneof_case_[0] = kSaveGame; -} -inline void Command::clear_savegame() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kSaveGame) { - if (GetArena() == nullptr) { - delete _impl_.command_.savegame_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.savegame_ != nullptr) { - _impl_.command_.savegame_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::SaveGame* Command::release_savegame() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.saveGame) - if (command_case() == kSaveGame) { - clear_has_command(); - auto* temp = _impl_.command_.savegame_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.savegame_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::SaveGame& Command::_internal_savegame() const { - return command_case() == kSaveGame ? *_impl_.command_.savegame_ : reinterpret_cast<::dapi::commands::SaveGame&>(::dapi::commands::_SaveGame_default_instance_); -} -inline const ::dapi::commands::SaveGame& Command::savegame() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.saveGame) - return _internal_savegame(); -} -inline ::dapi::commands::SaveGame* Command::unsafe_arena_release_savegame() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.saveGame) - if (command_case() == kSaveGame) { - clear_has_command(); - auto* temp = _impl_.command_.savegame_; - _impl_.command_.savegame_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_savegame(::dapi::commands::SaveGame* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_savegame(); - _impl_.command_.savegame_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.saveGame) -} -inline ::dapi::commands::SaveGame* Command::_internal_mutable_savegame() { - if (command_case() != kSaveGame) { - clear_command(); - set_has_savegame(); - _impl_.command_.savegame_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::SaveGame>(GetArena()); - } - return _impl_.command_.savegame_; -} -inline ::dapi::commands::SaveGame* Command::mutable_savegame() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::SaveGame* _msg = _internal_mutable_savegame(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.saveGame) - return _msg; -} - -// .dapi.commands.Quit quit = 31; -inline bool Command::has_quit() const { - return command_case() == kQuit; -} -inline bool Command::_internal_has_quit() const { - return command_case() == kQuit; -} -inline void Command::set_has_quit() { - _impl_._oneof_case_[0] = kQuit; -} -inline void Command::clear_quit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kQuit) { - if (GetArena() == nullptr) { - delete _impl_.command_.quit_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.quit_ != nullptr) { - _impl_.command_.quit_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::Quit* Command::release_quit() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.quit) - if (command_case() == kQuit) { - clear_has_command(); - auto* temp = _impl_.command_.quit_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.quit_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::Quit& Command::_internal_quit() const { - return command_case() == kQuit ? *_impl_.command_.quit_ : reinterpret_cast<::dapi::commands::Quit&>(::dapi::commands::_Quit_default_instance_); -} -inline const ::dapi::commands::Quit& Command::quit() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.quit) - return _internal_quit(); -} -inline ::dapi::commands::Quit* Command::unsafe_arena_release_quit() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.quit) - if (command_case() == kQuit) { - clear_has_command(); - auto* temp = _impl_.command_.quit_; - _impl_.command_.quit_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_quit(::dapi::commands::Quit* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_quit(); - _impl_.command_.quit_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.quit) -} -inline ::dapi::commands::Quit* Command::_internal_mutable_quit() { - if (command_case() != kQuit) { - clear_command(); - set_has_quit(); - _impl_.command_.quit_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Quit>(GetArena()); - } - return _impl_.command_.quit_; -} -inline ::dapi::commands::Quit* Command::mutable_quit() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::Quit* _msg = _internal_mutable_quit(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.quit) - return _msg; -} - -// .dapi.commands.ClearCursor clearCursor = 32; -inline bool Command::has_clearcursor() const { - return command_case() == kClearCursor; -} -inline bool Command::_internal_has_clearcursor() const { - return command_case() == kClearCursor; -} -inline void Command::set_has_clearcursor() { - _impl_._oneof_case_[0] = kClearCursor; -} -inline void Command::clear_clearcursor() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kClearCursor) { - if (GetArena() == nullptr) { - delete _impl_.command_.clearcursor_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.clearcursor_ != nullptr) { - _impl_.command_.clearcursor_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::ClearCursor* Command::release_clearcursor() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.clearCursor) - if (command_case() == kClearCursor) { - clear_has_command(); - auto* temp = _impl_.command_.clearcursor_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.clearcursor_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::ClearCursor& Command::_internal_clearcursor() const { - return command_case() == kClearCursor ? *_impl_.command_.clearcursor_ : reinterpret_cast<::dapi::commands::ClearCursor&>(::dapi::commands::_ClearCursor_default_instance_); -} -inline const ::dapi::commands::ClearCursor& Command::clearcursor() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.clearCursor) - return _internal_clearcursor(); -} -inline ::dapi::commands::ClearCursor* Command::unsafe_arena_release_clearcursor() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.clearCursor) - if (command_case() == kClearCursor) { - clear_has_command(); - auto* temp = _impl_.command_.clearcursor_; - _impl_.command_.clearcursor_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_clearcursor(::dapi::commands::ClearCursor* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_clearcursor(); - _impl_.command_.clearcursor_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.clearCursor) -} -inline ::dapi::commands::ClearCursor* Command::_internal_mutable_clearcursor() { - if (command_case() != kClearCursor) { - clear_command(); - set_has_clearcursor(); - _impl_.command_.clearcursor_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::ClearCursor>(GetArena()); - } - return _impl_.command_.clearcursor_; -} -inline ::dapi::commands::ClearCursor* Command::mutable_clearcursor() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::ClearCursor* _msg = _internal_mutable_clearcursor(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.clearCursor) - return _msg; -} - -// .dapi.commands.IdentifyItem identifyItem = 33; -inline bool Command::has_identifyitem() const { - return command_case() == kIdentifyItem; -} -inline bool Command::_internal_has_identifyitem() const { - return command_case() == kIdentifyItem; -} -inline void Command::set_has_identifyitem() { - _impl_._oneof_case_[0] = kIdentifyItem; -} -inline void Command::clear_identifyitem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (command_case() == kIdentifyItem) { - if (GetArena() == nullptr) { - delete _impl_.command_.identifyitem_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.command_.identifyitem_ != nullptr) { - _impl_.command_.identifyitem_->Clear(); - } - } - clear_has_command(); - } -} -inline ::dapi::commands::IdentifyItem* Command::release_identifyitem() { - // @@protoc_insertion_point(field_release:dapi.commands.Command.identifyItem) - if (command_case() == kIdentifyItem) { - clear_has_command(); - auto* temp = _impl_.command_.identifyitem_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.command_.identifyitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::IdentifyItem& Command::_internal_identifyitem() const { - return command_case() == kIdentifyItem ? *_impl_.command_.identifyitem_ : reinterpret_cast<::dapi::commands::IdentifyItem&>(::dapi::commands::_IdentifyItem_default_instance_); -} -inline const ::dapi::commands::IdentifyItem& Command::identifyitem() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.commands.Command.identifyItem) - return _internal_identifyitem(); -} -inline ::dapi::commands::IdentifyItem* Command::unsafe_arena_release_identifyitem() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.commands.Command.identifyItem) - if (command_case() == kIdentifyItem) { - clear_has_command(); - auto* temp = _impl_.command_.identifyitem_; - _impl_.command_.identifyitem_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Command::unsafe_arena_set_allocated_identifyitem(::dapi::commands::IdentifyItem* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_command(); - if (value) { - set_has_identifyitem(); - _impl_.command_.identifyitem_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.commands.Command.identifyItem) -} -inline ::dapi::commands::IdentifyItem* Command::_internal_mutable_identifyitem() { - if (command_case() != kIdentifyItem) { - clear_command(); - set_has_identifyitem(); - _impl_.command_.identifyitem_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::IdentifyItem>(GetArena()); - } - return _impl_.command_.identifyitem_; -} -inline ::dapi::commands::IdentifyItem* Command::mutable_identifyitem() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::IdentifyItem* _msg = _internal_mutable_identifyitem(); - // @@protoc_insertion_point(field_mutable:dapi.commands.Command.identifyItem) - return _msg; -} - -inline bool Command::has_command() const { - return command_case() != COMMAND_NOT_SET; -} -inline void Command::clear_has_command() { - _impl_._oneof_case_[0] = COMMAND_NOT_SET; -} -inline Command::CommandCase Command::command_case() const { - return Command::CommandCase(_impl_._oneof_case_[0]); -} -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ - -// @@protoc_insertion_point(namespace_scope) -} // namespace commands -} // namespace dapi - - -// @@protoc_insertion_point(global_scope) - -#include "google/protobuf/port_undef.inc" - -#endif // command_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/data.pb.cc b/Source/dapi/Backend/Messages/generated/data.pb.cc deleted file mode 100644 index 515b33f1d..000000000 --- a/Source/dapi/Backend/Messages/generated/data.pb.cc +++ /dev/null @@ -1,5512 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: data.proto -// Protobuf C++ Version: 5.29.3 - -#include "data.pb.h" - -#include -#include -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/generated_message_tctable_impl.h" -#include "google/protobuf/extension_set.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/wire_format_lite.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" -PROTOBUF_PRAGMA_INIT_SEG -namespace _pb = ::google::protobuf; -namespace _pbi = ::google::protobuf::internal; -namespace _fl = ::google::protobuf::internal::field_layout; -namespace dapi { -namespace data { - -inline constexpr TriggerData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : lvl_{0u}, - x_{0}, - y_{0}, - type_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR TriggerData::TriggerData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct TriggerDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR TriggerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~TriggerDataDefaultTypeInternal() {} - union { - TriggerData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TriggerDataDefaultTypeInternal _TriggerData_default_instance_; - -inline constexpr TownerData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _tname_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - id_{0u}, - _ttype_{0u}, - _tx_{0}, - _ty_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR TownerData::TownerData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct TownerDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR TownerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~TownerDataDefaultTypeInternal() {} - union { - TownerData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TownerDataDefaultTypeInternal _TownerData_default_instance_; - -inline constexpr TileData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : type_{0}, - x_{0}, - solid_{false}, - stopmissile_{false}, - y_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR TileData::TileData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct TileDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR TileDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~TileDataDefaultTypeInternal() {} - union { - TileData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 TileDataDefaultTypeInternal _TileData_default_instance_; - -inline constexpr QuestData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : id_{0u}, - state_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR QuestData::QuestData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct QuestDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR QuestDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~QuestDataDefaultTypeInternal() {} - union { - QuestData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 QuestDataDefaultTypeInternal _QuestData_default_instance_; - -inline constexpr PortalData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : x_{0u}, - y_{0u}, - player_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR PortalData::PortalData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct PortalDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR PortalDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~PortalDataDefaultTypeInternal() {} - union { - PortalData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PortalDataDefaultTypeInternal _PortalData_default_instance_; - -inline constexpr PlayerData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _pspllvl_{}, - __pspllvl_cached_byte_size_{0}, - invbody_{}, - _invbody_cached_byte_size_{0}, - invlist_{}, - _invlist_cached_byte_size_{0}, - invgrid_{}, - _invgrid_cached_byte_size_{0}, - spdlist_{}, - _spdlist_cached_byte_size_{0}, - _pname_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _pmode_{0}, - pnum_{0}, - plrlevel_{0}, - _px_{0}, - _py_{0}, - _pfutx_{0}, - _pfuty_{0}, - _pdir_{0}, - _prspell_{0}, - _prspltype_{0u}, - _pmemspells_{::uint64_t{0u}}, - _pablspells_{::uint64_t{0u}}, - _pscrlspells_{::uint64_t{0u}}, - _pclass_{0u}, - _pstrength_{0u}, - _pbasestr_{0u}, - _pmagic_{0u}, - _pbasemag_{0u}, - _pdexterity_{0u}, - _pbasedex_{0u}, - _pvitality_{0u}, - _pbasevit_{0u}, - _pstatpts_{0u}, - _pdamagemod_{0u}, - _phitpoints_{0u}, - _pmaxhp_{0u}, - _pmana_{0}, - _pmaxmana_{0u}, - _plevel_{0u}, - _pexperience_{0u}, - _parmorclass_{0u}, - _pmagresist_{0u}, - _pfireresist_{0u}, - _plightresist_{0u}, - _pgold_{0u}, - holditem_{0}, - _piac_{0u}, - _pimindam_{0u}, - _pimaxdam_{0u}, - _pibonusdam_{0u}, - _pibonustohit_{0u}, - _pibonusac_{0u}, - _pibonusdammod_{0u}, - pmanashield_{false}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR PlayerData::PlayerData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct PlayerDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR PlayerDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~PlayerDataDefaultTypeInternal() {} - union { - PlayerData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 PlayerDataDefaultTypeInternal _PlayerData_default_instance_; - -inline constexpr ObjectData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : x_{0u}, - y_{0u}, - type_{0}, - shrinetype_{0}, - doorstate_{0}, - solid_{false}, - selectable_{false}, - trapped_{false}, - index_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ObjectData::ObjectData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ObjectDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR ObjectDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ObjectDataDefaultTypeInternal() {} - union { - ObjectData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ObjectDataDefaultTypeInternal _ObjectData_default_instance_; - -inline constexpr MonsterData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : name_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - index_{0u}, - x_{0}, - y_{0}, - futx_{0}, - futy_{0}, - type_{0}, - kills_{0}, - mode_{0}, - unique_{false}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR MonsterData::MonsterData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct MonsterDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR MonsterDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~MonsterDataDefaultTypeInternal() {} - union { - MonsterData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MonsterDataDefaultTypeInternal _MonsterData_default_instance_; - -inline constexpr MissileData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : type_{0}, - x_{0u}, - y_{0u}, - xvel_{0}, - yvel_{0}, - sx_{0}, - sy_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR MissileData::MissileData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct MissileDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR MissileDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~MissileDataDefaultTypeInternal() {} - union { - MissileData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MissileDataDefaultTypeInternal _MissileData_default_instance_; - -inline constexpr ItemData::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _iname_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - _iiname_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - id_{0u}, - _itype_{0}, - _ix_{0}, - _iy_{0}, - _imagical_{0u}, - _iclass_{0u}, - _icurs_{0}, - _ivalue_{0}, - _imindam_{0}, - _imaxdam_{0}, - _iac_{0}, - _iflags_{0}, - _imiscid_{0}, - _ispell_{0}, - _icharges_{0}, - _imaxcharges_{0}, - _idurability_{0}, - _imaxdur_{0}, - _ipldam_{0}, - _ipltohit_{0}, - _iplac_{0}, - _iplstr_{0}, - _iplmag_{0}, - _iidentified_{false}, - _istatflag_{false}, - _ipldex_{0}, - _iplvit_{0}, - _iplfr_{0}, - _ipllr_{0}, - _iplmr_{0}, - _iplmana_{0}, - _iplhp_{0}, - _ipldammod_{0}, - _iplgethit_{0}, - _ipllight_{0}, - _ispllvladd_{0}, - _ifmindam_{0}, - _ifmaxdam_{0}, - _ilmindam_{0}, - _ilmaxdam_{0}, - _iprepower_{0}, - _isufpower_{0}, - _iminstr_{0}, - _iminmag_{0}, - _imindex_{0}, - ididx_{0}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ItemData::ItemData(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ItemDataDefaultTypeInternal { - PROTOBUF_CONSTEXPR ItemDataDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ItemDataDefaultTypeInternal() {} - union { - ItemData _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ItemDataDefaultTypeInternal _ItemData_default_instance_; -} // namespace data -} // namespace dapi -namespace dapi { -namespace data { -// =================================================================== - -class QuestData::_Internal { - public: -}; - -QuestData::QuestData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.QuestData) -} -QuestData::QuestData( - ::google::protobuf::Arena* arena, const QuestData& from) - : QuestData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE QuestData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void QuestData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, id_), - 0, - offsetof(Impl_, state_) - - offsetof(Impl_, id_) + - sizeof(Impl_::state_)); -} -QuestData::~QuestData() { - // @@protoc_insertion_point(destructor:dapi.data.QuestData) - SharedDtor(*this); -} -inline void QuestData::SharedDtor(MessageLite& self) { - QuestData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* QuestData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) QuestData(arena); -} -constexpr auto QuestData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(QuestData), - alignof(QuestData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<20> QuestData::_class_data_ = { - { - &_QuestData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &QuestData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &QuestData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &QuestData::ByteSizeLong, - &QuestData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(QuestData, _impl_._cached_size_), - true, - }, - "dapi.data.QuestData", -}; -const ::google::protobuf::internal::ClassData* QuestData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<1, 2, 0, 0, 2> QuestData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 2, 8, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967292, // skipmap - offsetof(decltype(_table_), field_entries), - 2, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::QuestData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 state = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_)}}, - // uint32 id = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 id = 1; - {PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 state = 2; - {PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void QuestData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.QuestData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.id_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.state_) - - reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.state_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* QuestData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const QuestData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* QuestData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const QuestData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.QuestData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 id = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - // uint32 state = 2; - if (this_._internal_state() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_state(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.QuestData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t QuestData::ByteSizeLong(const MessageLite& base) { - const QuestData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t QuestData::ByteSizeLong() const { - const QuestData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.QuestData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 id = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - // uint32 state = 2; - if (this_._internal_state() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_state()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void QuestData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.QuestData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - if (from._internal_state() != 0) { - _this->_impl_.state_ = from._impl_.state_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void QuestData::CopyFrom(const QuestData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.QuestData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void QuestData::InternalSwap(QuestData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(QuestData, _impl_.state_) - + sizeof(QuestData::_impl_.state_) - - PROTOBUF_FIELD_OFFSET(QuestData, _impl_.id_)>( - reinterpret_cast(&_impl_.id_), - reinterpret_cast(&other->_impl_.id_)); -} - -// =================================================================== - -class PortalData::_Internal { - public: -}; - -PortalData::PortalData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.PortalData) -} -PortalData::PortalData( - ::google::protobuf::Arena* arena, const PortalData& from) - : PortalData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE PortalData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void PortalData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, x_), - 0, - offsetof(Impl_, player_) - - offsetof(Impl_, x_) + - sizeof(Impl_::player_)); -} -PortalData::~PortalData() { - // @@protoc_insertion_point(destructor:dapi.data.PortalData) - SharedDtor(*this); -} -inline void PortalData::SharedDtor(MessageLite& self) { - PortalData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* PortalData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) PortalData(arena); -} -constexpr auto PortalData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(PortalData), - alignof(PortalData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> PortalData::_class_data_ = { - { - &_PortalData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &PortalData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &PortalData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &PortalData::ByteSizeLong, - &PortalData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(PortalData, _impl_._cached_size_), - true, - }, - "dapi.data.PortalData", -}; -const ::google::protobuf::internal::ClassData* PortalData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 3, 0, 0, 2> PortalData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 3, 24, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967288, // skipmap - offsetof(decltype(_table_), field_entries), - 3, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::PortalData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 x = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_)}}, - // uint32 y = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.y_)}}, - // uint32 player = 3; - {::_pbi::TcParser::FastV32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 x = 1; - {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 y = 2; - {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 player = 3; - {PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void PortalData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.PortalData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.x_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.player_) - - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.player_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* PortalData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const PortalData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* PortalData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const PortalData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.PortalData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 x = 1; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_x(), target); - } - - // uint32 y = 2; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_y(), target); - } - - // uint32 player = 3; - if (this_._internal_player() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 3, this_._internal_player(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.PortalData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t PortalData::ByteSizeLong(const MessageLite& base) { - const PortalData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t PortalData::ByteSizeLong() const { - const PortalData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.PortalData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 x = 1; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_x()); - } - // uint32 y = 2; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_y()); - } - // uint32 player = 3; - if (this_._internal_player() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_player()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void PortalData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.PortalData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - if (from._internal_player() != 0) { - _this->_impl_.player_ = from._impl_.player_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void PortalData::CopyFrom(const PortalData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.PortalData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void PortalData::InternalSwap(PortalData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(PortalData, _impl_.player_) - + sizeof(PortalData::_impl_.player_) - - PROTOBUF_FIELD_OFFSET(PortalData, _impl_.x_)>( - reinterpret_cast(&_impl_.x_), - reinterpret_cast(&other->_impl_.x_)); -} - -// =================================================================== - -class MissileData::_Internal { - public: -}; - -MissileData::MissileData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.MissileData) -} -MissileData::MissileData( - ::google::protobuf::Arena* arena, const MissileData& from) - : MissileData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE MissileData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void MissileData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, type_), - 0, - offsetof(Impl_, sy_) - - offsetof(Impl_, type_) + - sizeof(Impl_::sy_)); -} -MissileData::~MissileData() { - // @@protoc_insertion_point(destructor:dapi.data.MissileData) - SharedDtor(*this); -} -inline void MissileData::SharedDtor(MessageLite& self) { - MissileData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* MissileData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) MissileData(arena); -} -constexpr auto MissileData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(MissileData), - alignof(MissileData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> MissileData::_class_data_ = { - { - &_MissileData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &MissileData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &MissileData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &MissileData::ByteSizeLong, - &MissileData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(MissileData, _impl_._cached_size_), - true, - }, - "dapi.data.MissileData", -}; -const ::google::protobuf::internal::ClassData* MissileData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 7, 0, 0, 2> MissileData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 7, 56, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967168, // skipmap - offsetof(decltype(_table_), field_entries), - 7, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::MissileData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // sint32 type = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_)}}, - // uint32 x = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.x_)}}, - // uint32 y = 3; - {::_pbi::TcParser::FastV32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.y_)}}, - // sint32 xvel = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.xvel_)}}, - // sint32 yvel = 5; - {::_pbi::TcParser::FastZ32S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.yvel_)}}, - // sint32 sx = 6; - {::_pbi::TcParser::FastZ32S1, - {48, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sx_)}}, - // sint32 sy = 7; - {::_pbi::TcParser::FastZ32S1, - {56, 63, 0, PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 type = 1; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // uint32 x = 2; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 y = 3; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 xvel = 4; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.xvel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 yvel = 5; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.yvel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 sx = 6; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 sy = 7; - {PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void MissileData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.MissileData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.type_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.sy_) - - reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.sy_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* MissileData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const MissileData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* MissileData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const MissileData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.MissileData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 type = 1; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_type(), target); - } - - // uint32 x = 2; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_x(), target); - } - - // uint32 y = 3; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 3, this_._internal_y(), target); - } - - // sint32 xvel = 4; - if (this_._internal_xvel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal_xvel(), target); - } - - // sint32 yvel = 5; - if (this_._internal_yvel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 5, this_._internal_yvel(), target); - } - - // sint32 sx = 6; - if (this_._internal_sx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 6, this_._internal_sx(), target); - } - - // sint32 sy = 7; - if (this_._internal_sy() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 7, this_._internal_sy(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.MissileData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t MissileData::ByteSizeLong(const MessageLite& base) { - const MissileData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t MissileData::ByteSizeLong() const { - const MissileData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.MissileData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // sint32 type = 1; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_type()); - } - // uint32 x = 2; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_x()); - } - // uint32 y = 3; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_y()); - } - // sint32 xvel = 4; - if (this_._internal_xvel() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_xvel()); - } - // sint32 yvel = 5; - if (this_._internal_yvel() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_yvel()); - } - // sint32 sx = 6; - if (this_._internal_sx() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_sx()); - } - // sint32 sy = 7; - if (this_._internal_sy() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_sy()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void MissileData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.MissileData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - if (from._internal_xvel() != 0) { - _this->_impl_.xvel_ = from._impl_.xvel_; - } - if (from._internal_yvel() != 0) { - _this->_impl_.yvel_ = from._impl_.yvel_; - } - if (from._internal_sx() != 0) { - _this->_impl_.sx_ = from._impl_.sx_; - } - if (from._internal_sy() != 0) { - _this->_impl_.sy_ = from._impl_.sy_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void MissileData::CopyFrom(const MissileData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.MissileData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void MissileData::InternalSwap(MissileData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(MissileData, _impl_.sy_) - + sizeof(MissileData::_impl_.sy_) - - PROTOBUF_FIELD_OFFSET(MissileData, _impl_.type_)>( - reinterpret_cast(&_impl_.type_), - reinterpret_cast(&other->_impl_.type_)); -} - -// =================================================================== - -class ObjectData::_Internal { - public: -}; - -ObjectData::ObjectData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.ObjectData) -} -ObjectData::ObjectData( - ::google::protobuf::Arena* arena, const ObjectData& from) - : ObjectData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ObjectData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ObjectData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, x_), - 0, - offsetof(Impl_, index_) - - offsetof(Impl_, x_) + - sizeof(Impl_::index_)); -} -ObjectData::~ObjectData() { - // @@protoc_insertion_point(destructor:dapi.data.ObjectData) - SharedDtor(*this); -} -inline void ObjectData::SharedDtor(MessageLite& self) { - ObjectData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ObjectData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ObjectData(arena); -} -constexpr auto ObjectData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ObjectData), - alignof(ObjectData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> ObjectData::_class_data_ = { - { - &_ObjectData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ObjectData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ObjectData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ObjectData::ByteSizeLong, - &ObjectData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ObjectData, _impl_._cached_size_), - true, - }, - "dapi.data.ObjectData", -}; -const ::google::protobuf::internal::ClassData* ObjectData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<4, 9, 0, 0, 2> ObjectData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 9, 120, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294966784, // skipmap - offsetof(decltype(_table_), field_entries), - 9, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::ObjectData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 x = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_)}}, - // uint32 y = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.y_)}}, - // sint32 type = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.type_)}}, - // sint32 shrineType = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.shrinetype_)}}, - // bool solid = 5; - {::_pbi::TcParser::FastV8S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.solid_)}}, - // sint32 doorState = 6; - {::_pbi::TcParser::FastZ32S1, - {48, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.doorstate_)}}, - // bool selectable = 7; - {::_pbi::TcParser::FastV8S1, - {56, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.selectable_)}}, - // uint32 index = 8; - {::_pbi::TcParser::FastV32S1, - {64, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_)}}, - // bool trapped = 9; - {::_pbi::TcParser::FastV8S1, - {72, 63, 0, PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.trapped_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 x = 1; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 y = 2; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 type = 3; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 shrineType = 4; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.shrinetype_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool solid = 5; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.solid_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // sint32 doorState = 6; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.doorstate_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool selectable = 7; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.selectable_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // uint32 index = 8; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // bool trapped = 9; - {PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.trapped_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ObjectData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.ObjectData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.x_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.index_) - - reinterpret_cast(&_impl_.x_)) + sizeof(_impl_.index_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ObjectData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ObjectData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ObjectData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ObjectData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.ObjectData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 x = 1; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_x(), target); - } - - // uint32 y = 2; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal_y(), target); - } - - // sint32 type = 3; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_type(), target); - } - - // sint32 shrineType = 4; - if (this_._internal_shrinetype() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal_shrinetype(), target); - } - - // bool solid = 5; - if (this_._internal_solid() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 5, this_._internal_solid(), target); - } - - // sint32 doorState = 6; - if (this_._internal_doorstate() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 6, this_._internal_doorstate(), target); - } - - // bool selectable = 7; - if (this_._internal_selectable() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 7, this_._internal_selectable(), target); - } - - // uint32 index = 8; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 8, this_._internal_index(), target); - } - - // bool trapped = 9; - if (this_._internal_trapped() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 9, this_._internal_trapped(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.ObjectData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ObjectData::ByteSizeLong(const MessageLite& base) { - const ObjectData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ObjectData::ByteSizeLong() const { - const ObjectData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.ObjectData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 x = 1; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_x()); - } - // uint32 y = 2; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_y()); - } - // sint32 type = 3; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_type()); - } - // sint32 shrineType = 4; - if (this_._internal_shrinetype() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_shrinetype()); - } - // sint32 doorState = 6; - if (this_._internal_doorstate() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_doorstate()); - } - // bool solid = 5; - if (this_._internal_solid() != 0) { - total_size += 2; - } - // bool selectable = 7; - if (this_._internal_selectable() != 0) { - total_size += 2; - } - // bool trapped = 9; - if (this_._internal_trapped() != 0) { - total_size += 2; - } - // uint32 index = 8; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ObjectData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.ObjectData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - if (from._internal_shrinetype() != 0) { - _this->_impl_.shrinetype_ = from._impl_.shrinetype_; - } - if (from._internal_doorstate() != 0) { - _this->_impl_.doorstate_ = from._impl_.doorstate_; - } - if (from._internal_solid() != 0) { - _this->_impl_.solid_ = from._impl_.solid_; - } - if (from._internal_selectable() != 0) { - _this->_impl_.selectable_ = from._impl_.selectable_; - } - if (from._internal_trapped() != 0) { - _this->_impl_.trapped_ = from._impl_.trapped_; - } - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ObjectData::CopyFrom(const ObjectData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.ObjectData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ObjectData::InternalSwap(ObjectData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.index_) - + sizeof(ObjectData::_impl_.index_) - - PROTOBUF_FIELD_OFFSET(ObjectData, _impl_.x_)>( - reinterpret_cast(&_impl_.x_), - reinterpret_cast(&other->_impl_.x_)); -} - -// =================================================================== - -class MonsterData::_Internal { - public: -}; - -MonsterData::MonsterData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.MonsterData) -} -inline PROTOBUF_NDEBUG_INLINE MonsterData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::data::MonsterData& from_msg) - : name_(arena, from.name_), - _cached_size_{0} {} - -MonsterData::MonsterData( - ::google::protobuf::Arena* arena, - const MonsterData& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - MonsterData* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, index_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, index_), - offsetof(Impl_, unique_) - - offsetof(Impl_, index_) + - sizeof(Impl_::unique_)); - - // @@protoc_insertion_point(copy_constructor:dapi.data.MonsterData) -} -inline PROTOBUF_NDEBUG_INLINE MonsterData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : name_(arena), - _cached_size_{0} {} - -inline void MonsterData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, index_), - 0, - offsetof(Impl_, unique_) - - offsetof(Impl_, index_) + - sizeof(Impl_::unique_)); -} -MonsterData::~MonsterData() { - // @@protoc_insertion_point(destructor:dapi.data.MonsterData) - SharedDtor(*this); -} -inline void MonsterData::SharedDtor(MessageLite& self) { - MonsterData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.name_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* MonsterData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) MonsterData(arena); -} -constexpr auto MonsterData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(MonsterData), - alignof(MonsterData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> MonsterData::_class_data_ = { - { - &_MonsterData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &MonsterData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &MonsterData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &MonsterData::ByteSizeLong, - &MonsterData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(MonsterData, _impl_._cached_size_), - true, - }, - "dapi.data.MonsterData", -}; -const ::google::protobuf::internal::ClassData* MonsterData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<4, 10, 0, 42, 2> MonsterData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 10, 120, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294966272, // skipmap - offsetof(decltype(_table_), field_entries), - 10, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::MonsterData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 index = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_)}}, - // sint32 x = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.x_)}}, - // sint32 y = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.y_)}}, - // sint32 futx = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futx_)}}, - // sint32 futy = 5; - {::_pbi::TcParser::FastZ32S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futy_)}}, - // string name = 6; - {::_pbi::TcParser::FastUS1, - {50, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.name_)}}, - // sint32 type = 7; - {::_pbi::TcParser::FastZ32S1, - {56, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.type_)}}, - // sint32 kills = 8; - {::_pbi::TcParser::FastZ32S1, - {64, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.kills_)}}, - // sint32 mode = 9; - {::_pbi::TcParser::FastZ32S1, - {72, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.mode_)}}, - // bool unique = 10; - {::_pbi::TcParser::FastV8S1, - {80, 63, 0, PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 index = 1; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 x = 2; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 y = 3; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 futx = 4; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 futy = 5; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.futy_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // string name = 6; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.name_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // sint32 type = 7; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 kills = 8; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.kills_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 mode = 9; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.mode_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool unique = 10; - {PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - }}, - // no aux_entries - {{ - "\25\0\0\0\0\0\4\0\0\0\0\0\0\0\0\0" - "dapi.data.MonsterData" - "name" - }}, -}; - -PROTOBUF_NOINLINE void MonsterData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.MonsterData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.name_.ClearToEmpty(); - ::memset(&_impl_.index_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.unique_) - - reinterpret_cast(&_impl_.index_)) + sizeof(_impl_.unique_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* MonsterData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const MonsterData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* MonsterData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const MonsterData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.MonsterData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 index = 1; - if (this_._internal_index() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_index(), target); - } - - // sint32 x = 2; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_x(), target); - } - - // sint32 y = 3; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_y(), target); - } - - // sint32 futx = 4; - if (this_._internal_futx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal_futx(), target); - } - - // sint32 futy = 5; - if (this_._internal_futy() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 5, this_._internal_futy(), target); - } - - // string name = 6; - if (!this_._internal_name().empty()) { - const std::string& _s = this_._internal_name(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.MonsterData.name"); - target = stream->WriteStringMaybeAliased(6, _s, target); - } - - // sint32 type = 7; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 7, this_._internal_type(), target); - } - - // sint32 kills = 8; - if (this_._internal_kills() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 8, this_._internal_kills(), target); - } - - // sint32 mode = 9; - if (this_._internal_mode() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 9, this_._internal_mode(), target); - } - - // bool unique = 10; - if (this_._internal_unique() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 10, this_._internal_unique(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.MonsterData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t MonsterData::ByteSizeLong(const MessageLite& base) { - const MonsterData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t MonsterData::ByteSizeLong() const { - const MonsterData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.MonsterData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // string name = 6; - if (!this_._internal_name().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_name()); - } - // uint32 index = 1; - if (this_._internal_index() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_index()); - } - // sint32 x = 2; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_x()); - } - // sint32 y = 3; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_y()); - } - // sint32 futx = 4; - if (this_._internal_futx() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_futx()); - } - // sint32 futy = 5; - if (this_._internal_futy() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_futy()); - } - // sint32 type = 7; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_type()); - } - // sint32 kills = 8; - if (this_._internal_kills() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_kills()); - } - // sint32 mode = 9; - if (this_._internal_mode() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_mode()); - } - // bool unique = 10; - if (this_._internal_unique() != 0) { - total_size += 2; - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void MonsterData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.MonsterData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal_name().empty()) { - _this->_internal_set_name(from._internal_name()); - } - if (from._internal_index() != 0) { - _this->_impl_.index_ = from._impl_.index_; - } - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - if (from._internal_futx() != 0) { - _this->_impl_.futx_ = from._impl_.futx_; - } - if (from._internal_futy() != 0) { - _this->_impl_.futy_ = from._impl_.futy_; - } - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - if (from._internal_kills() != 0) { - _this->_impl_.kills_ = from._impl_.kills_; - } - if (from._internal_mode() != 0) { - _this->_impl_.mode_ = from._impl_.mode_; - } - if (from._internal_unique() != 0) { - _this->_impl_.unique_ = from._impl_.unique_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void MonsterData::CopyFrom(const MonsterData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.MonsterData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void MonsterData::InternalSwap(MonsterData* PROTOBUF_RESTRICT other) { - using std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.name_, &other->_impl_.name_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.unique_) - + sizeof(MonsterData::_impl_.unique_) - - PROTOBUF_FIELD_OFFSET(MonsterData, _impl_.index_)>( - reinterpret_cast(&_impl_.index_), - reinterpret_cast(&other->_impl_.index_)); -} - -// =================================================================== - -class TriggerData::_Internal { - public: -}; - -TriggerData::TriggerData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.TriggerData) -} -TriggerData::TriggerData( - ::google::protobuf::Arena* arena, const TriggerData& from) - : TriggerData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE TriggerData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void TriggerData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, lvl_), - 0, - offsetof(Impl_, type_) - - offsetof(Impl_, lvl_) + - sizeof(Impl_::type_)); -} -TriggerData::~TriggerData() { - // @@protoc_insertion_point(destructor:dapi.data.TriggerData) - SharedDtor(*this); -} -inline void TriggerData::SharedDtor(MessageLite& self) { - TriggerData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* TriggerData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) TriggerData(arena); -} -constexpr auto TriggerData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TriggerData), - alignof(TriggerData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> TriggerData::_class_data_ = { - { - &_TriggerData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &TriggerData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &TriggerData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &TriggerData::ByteSizeLong, - &TriggerData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(TriggerData, _impl_._cached_size_), - true, - }, - "dapi.data.TriggerData", -}; -const ::google::protobuf::internal::ClassData* TriggerData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<2, 4, 0, 0, 2> TriggerData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 4, 24, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967280, // skipmap - offsetof(decltype(_table_), field_entries), - 4, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::TriggerData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // sint32 type = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_)}}, - // uint32 lvl = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_)}}, - // sint32 x = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.x_)}}, - // sint32 y = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.y_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 lvl = 1; - {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 x = 2; - {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 y = 3; - {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 type = 4; - {PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void TriggerData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.TriggerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.lvl_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.type_) - - reinterpret_cast(&_impl_.lvl_)) + sizeof(_impl_.type_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* TriggerData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const TriggerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* TriggerData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const TriggerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TriggerData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 lvl = 1; - if (this_._internal_lvl() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_lvl(), target); - } - - // sint32 x = 2; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_x(), target); - } - - // sint32 y = 3; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_y(), target); - } - - // sint32 type = 4; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal_type(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TriggerData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t TriggerData::ByteSizeLong(const MessageLite& base) { - const TriggerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t TriggerData::ByteSizeLong() const { - const TriggerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.TriggerData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // uint32 lvl = 1; - if (this_._internal_lvl() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_lvl()); - } - // sint32 x = 2; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_x()); - } - // sint32 y = 3; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_y()); - } - // sint32 type = 4; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_type()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void TriggerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TriggerData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_lvl() != 0) { - _this->_impl_.lvl_ = from._impl_.lvl_; - } - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void TriggerData::CopyFrom(const TriggerData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TriggerData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void TriggerData::InternalSwap(TriggerData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.type_) - + sizeof(TriggerData::_impl_.type_) - - PROTOBUF_FIELD_OFFSET(TriggerData, _impl_.lvl_)>( - reinterpret_cast(&_impl_.lvl_), - reinterpret_cast(&other->_impl_.lvl_)); -} - -// =================================================================== - -class TileData::_Internal { - public: -}; - -TileData::TileData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.TileData) -} -TileData::TileData( - ::google::protobuf::Arena* arena, const TileData& from) - : TileData(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE TileData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void TileData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, type_), - 0, - offsetof(Impl_, y_) - - offsetof(Impl_, type_) + - sizeof(Impl_::y_)); -} -TileData::~TileData() { - // @@protoc_insertion_point(destructor:dapi.data.TileData) - SharedDtor(*this); -} -inline void TileData::SharedDtor(MessageLite& self) { - TileData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* TileData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) TileData(arena); -} -constexpr auto TileData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(TileData), - alignof(TileData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<19> TileData::_class_data_ = { - { - &_TileData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &TileData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &TileData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &TileData::ByteSizeLong, - &TileData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(TileData, _impl_._cached_size_), - true, - }, - "dapi.data.TileData", -}; -const ::google::protobuf::internal::ClassData* TileData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 5, 0, 0, 2> TileData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 5, 56, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967264, // skipmap - offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::TileData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // sint32 type = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_)}}, - // bool solid = 2; - {::_pbi::TcParser::FastV8S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.solid_)}}, - // sint32 x = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.x_)}}, - // sint32 y = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_)}}, - // bool stopMissile = 5; - {::_pbi::TcParser::FastV8S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(TileData, _impl_.stopmissile_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // sint32 type = 1; - {PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool solid = 2; - {PROTOBUF_FIELD_OFFSET(TileData, _impl_.solid_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // sint32 x = 3; - {PROTOBUF_FIELD_OFFSET(TileData, _impl_.x_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 y = 4; - {PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool stopMissile = 5; - {PROTOBUF_FIELD_OFFSET(TileData, _impl_.stopmissile_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void TileData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.TileData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&_impl_.type_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.y_) - - reinterpret_cast(&_impl_.type_)) + sizeof(_impl_.y_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* TileData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const TileData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* TileData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const TileData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TileData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 type = 1; - if (this_._internal_type() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal_type(), target); - } - - // bool solid = 2; - if (this_._internal_solid() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 2, this_._internal_solid(), target); - } - - // sint32 x = 3; - if (this_._internal_x() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_x(), target); - } - - // sint32 y = 4; - if (this_._internal_y() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal_y(), target); - } - - // bool stopMissile = 5; - if (this_._internal_stopmissile() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 5, this_._internal_stopmissile(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TileData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t TileData::ByteSizeLong(const MessageLite& base) { - const TileData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t TileData::ByteSizeLong() const { - const TileData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.TileData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // sint32 type = 1; - if (this_._internal_type() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_type()); - } - // sint32 x = 3; - if (this_._internal_x() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_x()); - } - // bool solid = 2; - if (this_._internal_solid() != 0) { - total_size += 2; - } - // bool stopMissile = 5; - if (this_._internal_stopmissile() != 0) { - total_size += 2; - } - // sint32 y = 4; - if (this_._internal_y() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_y()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void TileData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TileData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_type() != 0) { - _this->_impl_.type_ = from._impl_.type_; - } - if (from._internal_x() != 0) { - _this->_impl_.x_ = from._impl_.x_; - } - if (from._internal_solid() != 0) { - _this->_impl_.solid_ = from._impl_.solid_; - } - if (from._internal_stopmissile() != 0) { - _this->_impl_.stopmissile_ = from._impl_.stopmissile_; - } - if (from._internal_y() != 0) { - _this->_impl_.y_ = from._impl_.y_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void TileData::CopyFrom(const TileData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TileData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void TileData::InternalSwap(TileData* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(TileData, _impl_.y_) - + sizeof(TileData::_impl_.y_) - - PROTOBUF_FIELD_OFFSET(TileData, _impl_.type_)>( - reinterpret_cast(&_impl_.type_), - reinterpret_cast(&other->_impl_.type_)); -} - -// =================================================================== - -class TownerData::_Internal { - public: -}; - -TownerData::TownerData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.TownerData) -} -inline PROTOBUF_NDEBUG_INLINE TownerData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::data::TownerData& from_msg) - : _tname_(arena, from._tname_), - _cached_size_{0} {} - -TownerData::TownerData( - ::google::protobuf::Arena* arena, - const TownerData& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - TownerData* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, id_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, id_), - offsetof(Impl_, _ty_) - - offsetof(Impl_, id_) + - sizeof(Impl_::_ty_)); - - // @@protoc_insertion_point(copy_constructor:dapi.data.TownerData) -} -inline PROTOBUF_NDEBUG_INLINE TownerData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _tname_(arena), - _cached_size_{0} {} - -inline void TownerData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, id_), - 0, - offsetof(Impl_, _ty_) - - offsetof(Impl_, id_) + - sizeof(Impl_::_ty_)); -} -TownerData::~TownerData() { - // @@protoc_insertion_point(destructor:dapi.data.TownerData) - SharedDtor(*this); -} -inline void TownerData::SharedDtor(MessageLite& self) { - TownerData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_._tname_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* TownerData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) TownerData(arena); -} -constexpr auto TownerData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(TownerData), - alignof(TownerData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> TownerData::_class_data_ = { - { - &_TownerData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &TownerData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &TownerData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &TownerData::ByteSizeLong, - &TownerData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(TownerData, _impl_._cached_size_), - true, - }, - "dapi.data.TownerData", -}; -const ::google::protobuf::internal::ClassData* TownerData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<3, 5, 0, 35, 2> TownerData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 5, 56, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967264, // skipmap - offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::TownerData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_)}}, - // uint32 _ttype = 2; - {::_pbi::TcParser::FastV32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ttype_)}}, - // sint32 _tx = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tx_)}}, - // sint32 _ty = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_)}}, - // string _tName = 5; - {::_pbi::TcParser::FastUS1, - {42, 63, 0, PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tname_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _ttype = 2; - {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ttype_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 _tx = 3; - {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _ty = 4; - {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // string _tName = 5; - {PROTOBUF_FIELD_OFFSET(TownerData, _impl_._tname_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - }}, - // no aux_entries - {{ - "\24\0\0\0\0\6\0\0" - "dapi.data.TownerData" - "_tName" - }}, -}; - -PROTOBUF_NOINLINE void TownerData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.TownerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_._tname_.ClearToEmpty(); - ::memset(&_impl_.id_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_._ty_) - - reinterpret_cast(&_impl_.id_)) + sizeof(_impl_._ty_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* TownerData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const TownerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* TownerData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const TownerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.TownerData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - // uint32 _ttype = 2; - if (this_._internal__ttype() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 2, this_._internal__ttype(), target); - } - - // sint32 _tx = 3; - if (this_._internal__tx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal__tx(), target); - } - - // sint32 _ty = 4; - if (this_._internal__ty() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal__ty(), target); - } - - // string _tName = 5; - if (!this_._internal__tname().empty()) { - const std::string& _s = this_._internal__tname(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.TownerData._tName"); - target = stream->WriteStringMaybeAliased(5, _s, target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.TownerData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t TownerData::ByteSizeLong(const MessageLite& base) { - const TownerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t TownerData::ByteSizeLong() const { - const TownerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.TownerData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // string _tName = 5; - if (!this_._internal__tname().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal__tname()); - } - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - // uint32 _ttype = 2; - if (this_._internal__ttype() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal__ttype()); - } - // sint32 _tx = 3; - if (this_._internal__tx() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__tx()); - } - // sint32 _ty = 4; - if (this_._internal__ty() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__ty()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void TownerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.TownerData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal__tname().empty()) { - _this->_internal_set__tname(from._internal__tname()); - } - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - if (from._internal__ttype() != 0) { - _this->_impl_._ttype_ = from._impl_._ttype_; - } - if (from._internal__tx() != 0) { - _this->_impl_._tx_ = from._impl_._tx_; - } - if (from._internal__ty() != 0) { - _this->_impl_._ty_ = from._impl_._ty_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void TownerData::CopyFrom(const TownerData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.TownerData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void TownerData::InternalSwap(TownerData* PROTOBUF_RESTRICT other) { - using std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._tname_, &other->_impl_._tname_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(TownerData, _impl_._ty_) - + sizeof(TownerData::_impl_._ty_) - - PROTOBUF_FIELD_OFFSET(TownerData, _impl_.id_)>( - reinterpret_cast(&_impl_.id_), - reinterpret_cast(&other->_impl_.id_)); -} - -// =================================================================== - -class ItemData::_Internal { - public: -}; - -ItemData::ItemData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.ItemData) -} -inline PROTOBUF_NDEBUG_INLINE ItemData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::data::ItemData& from_msg) - : _iname_(arena, from._iname_), - _iiname_(arena, from._iiname_), - _cached_size_{0} {} - -ItemData::ItemData( - ::google::protobuf::Arena* arena, - const ItemData& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - ItemData* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, id_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, id_), - offsetof(Impl_, ididx_) - - offsetof(Impl_, id_) + - sizeof(Impl_::ididx_)); - - // @@protoc_insertion_point(copy_constructor:dapi.data.ItemData) -} -inline PROTOBUF_NDEBUG_INLINE ItemData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _iname_(arena), - _iiname_(arena), - _cached_size_{0} {} - -inline void ItemData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, id_), - 0, - offsetof(Impl_, ididx_) - - offsetof(Impl_, id_) + - sizeof(Impl_::ididx_)); -} -ItemData::~ItemData() { - // @@protoc_insertion_point(destructor:dapi.data.ItemData) - SharedDtor(*this); -} -inline void ItemData::SharedDtor(MessageLite& self) { - ItemData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_._iname_.Destroy(); - this_._impl_._iiname_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* ItemData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ItemData(arena); -} -constexpr auto ItemData::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::CopyInit(sizeof(ItemData), - alignof(ItemData)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<19> ItemData::_class_data_ = { - { - &_ItemData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ItemData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ItemData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ItemData::ByteSizeLong, - &ItemData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ItemData, _impl_._cached_size_), - true, - }, - "dapi.data.ItemData", -}; -const ::google::protobuf::internal::ClassData* ItemData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<5, 48, 0, 88, 7> ItemData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 48, 248, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 0, // skipmap - offsetof(decltype(_table_), field_entries), - 48, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::ItemData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 ID = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_)}}, - // sint32 _itype = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._itype_)}}, - // sint32 _ix = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ix_)}}, - // sint32 _iy = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iy_)}}, - // bool _iIdentified = 5; - {::_pbi::TcParser::FastV8S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iidentified_)}}, - // uint32 _iMagical = 6; - {::_pbi::TcParser::FastV32S1, - {48, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imagical_)}}, - // string _iName = 7; - {::_pbi::TcParser::FastUS1, - {58, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iname_)}}, - // string _iIName = 8; - {::_pbi::TcParser::FastUS1, - {66, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iiname_)}}, - // uint32 _iClass = 9; - {::_pbi::TcParser::FastV32S1, - {72, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iclass_)}}, - // sint32 _iCurs = 10; - {::_pbi::TcParser::FastZ32S1, - {80, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icurs_)}}, - // sint32 _iValue = 11; - {::_pbi::TcParser::FastZ32S1, - {88, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ivalue_)}}, - // sint32 _iMinDam = 12; - {::_pbi::TcParser::FastZ32S1, - {96, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindam_)}}, - // sint32 _iMaxDam = 13; - {::_pbi::TcParser::FastZ32S1, - {104, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdam_)}}, - // sint32 _iAC = 14; - {::_pbi::TcParser::FastZ32S1, - {112, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iac_)}}, - // sint32 _iFlags = 15; - {::_pbi::TcParser::FastZ32S1, - {120, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iflags_)}}, - // sint32 _iMiscId = 16; - {::_pbi::TcParser::FastZ32S2, - {384, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imiscid_)}}, - // sint32 _iSpell = 17; - {::_pbi::TcParser::FastZ32S2, - {392, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispell_)}}, - // sint32 _iCharges = 18; - {::_pbi::TcParser::FastZ32S2, - {400, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icharges_)}}, - // sint32 _iMaxCharges = 19; - {::_pbi::TcParser::FastZ32S2, - {408, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxcharges_)}}, - // sint32 _iDurability = 20; - {::_pbi::TcParser::FastZ32S2, - {416, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._idurability_)}}, - // sint32 _iMaxDur = 21; - {::_pbi::TcParser::FastZ32S2, - {424, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdur_)}}, - // sint32 _iPLDam = 22; - {::_pbi::TcParser::FastZ32S2, - {432, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldam_)}}, - // sint32 _iPLToHit = 23; - {::_pbi::TcParser::FastZ32S2, - {440, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipltohit_)}}, - // sint32 _iPLAC = 24; - {::_pbi::TcParser::FastZ32S2, - {448, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplac_)}}, - // sint32 _iPLStr = 25; - {::_pbi::TcParser::FastZ32S2, - {456, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplstr_)}}, - // sint32 _iPLMag = 26; - {::_pbi::TcParser::FastZ32S2, - {464, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmag_)}}, - // sint32 _iPLDex = 27; - {::_pbi::TcParser::FastZ32S2, - {472, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldex_)}}, - // sint32 _iPLVit = 28; - {::_pbi::TcParser::FastZ32S2, - {480, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplvit_)}}, - // sint32 _iPLFR = 29; - {::_pbi::TcParser::FastZ32S2, - {488, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplfr_)}}, - // sint32 _iPLLR = 30; - {::_pbi::TcParser::FastZ32S2, - {496, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllr_)}}, - // sint32 _iPLMR = 31; - {::_pbi::TcParser::FastZ32S2, - {504, 63, 0, PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmr_)}}, - }}, {{ - 33, 0, 1, - 0, 32, - 65535, 65535 - }}, {{ - // uint32 ID = 1; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 _itype = 2; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._itype_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _ix = 3; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ix_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iy = 4; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iy_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool _iIdentified = 5; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iidentified_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // uint32 _iMagical = 6; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imagical_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // string _iName = 7; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iname_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // string _iIName = 8; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iiname_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 _iClass = 9; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iclass_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 _iCurs = 10; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icurs_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iValue = 11; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ivalue_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMinDam = 12; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMaxDam = 13; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iAC = 14; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iac_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iFlags = 15; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iflags_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMiscId = 16; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imiscid_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iSpell = 17; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispell_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iCharges = 18; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._icharges_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMaxCharges = 19; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxcharges_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iDurability = 20; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._idurability_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMaxDur = 21; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imaxdur_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLDam = 22; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLToHit = 23; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipltohit_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLAC = 24; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplac_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLStr = 25; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplstr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLMag = 26; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLDex = 27; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldex_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLVit = 28; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplvit_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLFR = 29; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplfr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLLR = 30; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLMR = 31; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLMana = 32; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplmana_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLHP = 33; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplhp_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLDamMod = 34; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipldammod_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLGetHit = 35; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iplgethit_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPLLight = 36; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ipllight_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iSplLvlAdd = 37; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ispllvladd_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iFMinDam = 38; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ifmindam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iFMaxDam = 39; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ifmaxdam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iLMinDam = 40; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ilmindam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iLMaxDam = 41; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._ilmaxdam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iPrePower = 42; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iprepower_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iSufPower = 43; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._isufpower_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMinStr = 44; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iminstr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMinMag = 45; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._iminmag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _iMinDex = 46; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._imindex_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool _iStatFlag = 47; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_._istatflag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // sint32 IDidx = 48; - {PROTOBUF_FIELD_OFFSET(ItemData, _impl_.ididx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - }}, - // no aux_entries - {{ - "\22\0\0\0\0\0\0\6\7\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" - "dapi.data.ItemData" - "_iName" - "_iIName" - }}, -}; - -PROTOBUF_NOINLINE void ItemData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.ItemData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_._iname_.ClearToEmpty(); - _impl_._iiname_.ClearToEmpty(); - ::memset(&_impl_.id_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.ididx_) - - reinterpret_cast(&_impl_.id_)) + sizeof(_impl_.ididx_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ItemData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ItemData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ItemData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ItemData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.ItemData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 ID = 1; - if (this_._internal_id() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_id(), target); - } - - // sint32 _itype = 2; - if (this_._internal__itype() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal__itype(), target); - } - - // sint32 _ix = 3; - if (this_._internal__ix() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal__ix(), target); - } - - // sint32 _iy = 4; - if (this_._internal__iy() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal__iy(), target); - } - - // bool _iIdentified = 5; - if (this_._internal__iidentified() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 5, this_._internal__iidentified(), target); - } - - // uint32 _iMagical = 6; - if (this_._internal__imagical() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 6, this_._internal__imagical(), target); - } - - // string _iName = 7; - if (!this_._internal__iname().empty()) { - const std::string& _s = this_._internal__iname(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.ItemData._iName"); - target = stream->WriteStringMaybeAliased(7, _s, target); - } - - // string _iIName = 8; - if (!this_._internal__iiname().empty()) { - const std::string& _s = this_._internal__iiname(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.ItemData._iIName"); - target = stream->WriteStringMaybeAliased(8, _s, target); - } - - // uint32 _iClass = 9; - if (this_._internal__iclass() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 9, this_._internal__iclass(), target); - } - - // sint32 _iCurs = 10; - if (this_._internal__icurs() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 10, this_._internal__icurs(), target); - } - - // sint32 _iValue = 11; - if (this_._internal__ivalue() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 11, this_._internal__ivalue(), target); - } - - // sint32 _iMinDam = 12; - if (this_._internal__imindam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 12, this_._internal__imindam(), target); - } - - // sint32 _iMaxDam = 13; - if (this_._internal__imaxdam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 13, this_._internal__imaxdam(), target); - } - - // sint32 _iAC = 14; - if (this_._internal__iac() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 14, this_._internal__iac(), target); - } - - // sint32 _iFlags = 15; - if (this_._internal__iflags() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 15, this_._internal__iflags(), target); - } - - // sint32 _iMiscId = 16; - if (this_._internal__imiscid() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 16, this_._internal__imiscid(), target); - } - - // sint32 _iSpell = 17; - if (this_._internal__ispell() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 17, this_._internal__ispell(), target); - } - - // sint32 _iCharges = 18; - if (this_._internal__icharges() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 18, this_._internal__icharges(), target); - } - - // sint32 _iMaxCharges = 19; - if (this_._internal__imaxcharges() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 19, this_._internal__imaxcharges(), target); - } - - // sint32 _iDurability = 20; - if (this_._internal__idurability() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 20, this_._internal__idurability(), target); - } - - // sint32 _iMaxDur = 21; - if (this_._internal__imaxdur() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 21, this_._internal__imaxdur(), target); - } - - // sint32 _iPLDam = 22; - if (this_._internal__ipldam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 22, this_._internal__ipldam(), target); - } - - // sint32 _iPLToHit = 23; - if (this_._internal__ipltohit() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 23, this_._internal__ipltohit(), target); - } - - // sint32 _iPLAC = 24; - if (this_._internal__iplac() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 24, this_._internal__iplac(), target); - } - - // sint32 _iPLStr = 25; - if (this_._internal__iplstr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 25, this_._internal__iplstr(), target); - } - - // sint32 _iPLMag = 26; - if (this_._internal__iplmag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 26, this_._internal__iplmag(), target); - } - - // sint32 _iPLDex = 27; - if (this_._internal__ipldex() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 27, this_._internal__ipldex(), target); - } - - // sint32 _iPLVit = 28; - if (this_._internal__iplvit() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 28, this_._internal__iplvit(), target); - } - - // sint32 _iPLFR = 29; - if (this_._internal__iplfr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 29, this_._internal__iplfr(), target); - } - - // sint32 _iPLLR = 30; - if (this_._internal__ipllr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 30, this_._internal__ipllr(), target); - } - - // sint32 _iPLMR = 31; - if (this_._internal__iplmr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 31, this_._internal__iplmr(), target); - } - - // sint32 _iPLMana = 32; - if (this_._internal__iplmana() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 32, this_._internal__iplmana(), target); - } - - // sint32 _iPLHP = 33; - if (this_._internal__iplhp() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 33, this_._internal__iplhp(), target); - } - - // sint32 _iPLDamMod = 34; - if (this_._internal__ipldammod() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 34, this_._internal__ipldammod(), target); - } - - // sint32 _iPLGetHit = 35; - if (this_._internal__iplgethit() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 35, this_._internal__iplgethit(), target); - } - - // sint32 _iPLLight = 36; - if (this_._internal__ipllight() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 36, this_._internal__ipllight(), target); - } - - // sint32 _iSplLvlAdd = 37; - if (this_._internal__ispllvladd() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 37, this_._internal__ispllvladd(), target); - } - - // sint32 _iFMinDam = 38; - if (this_._internal__ifmindam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 38, this_._internal__ifmindam(), target); - } - - // sint32 _iFMaxDam = 39; - if (this_._internal__ifmaxdam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 39, this_._internal__ifmaxdam(), target); - } - - // sint32 _iLMinDam = 40; - if (this_._internal__ilmindam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 40, this_._internal__ilmindam(), target); - } - - // sint32 _iLMaxDam = 41; - if (this_._internal__ilmaxdam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 41, this_._internal__ilmaxdam(), target); - } - - // sint32 _iPrePower = 42; - if (this_._internal__iprepower() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 42, this_._internal__iprepower(), target); - } - - // sint32 _iSufPower = 43; - if (this_._internal__isufpower() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 43, this_._internal__isufpower(), target); - } - - // sint32 _iMinStr = 44; - if (this_._internal__iminstr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 44, this_._internal__iminstr(), target); - } - - // sint32 _iMinMag = 45; - if (this_._internal__iminmag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 45, this_._internal__iminmag(), target); - } - - // sint32 _iMinDex = 46; - if (this_._internal__imindex() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 46, this_._internal__imindex(), target); - } - - // bool _iStatFlag = 47; - if (this_._internal__istatflag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 47, this_._internal__istatflag(), target); - } - - // sint32 IDidx = 48; - if (this_._internal_ididx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 48, this_._internal_ididx(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.ItemData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ItemData::ByteSizeLong(const MessageLite& base) { - const ItemData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ItemData::ByteSizeLong() const { - const ItemData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.ItemData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // string _iName = 7; - if (!this_._internal__iname().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal__iname()); - } - // string _iIName = 8; - if (!this_._internal__iiname().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal__iiname()); - } - // uint32 ID = 1; - if (this_._internal_id() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_id()); - } - // sint32 _itype = 2; - if (this_._internal__itype() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__itype()); - } - // sint32 _ix = 3; - if (this_._internal__ix() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__ix()); - } - // sint32 _iy = 4; - if (this_._internal__iy() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__iy()); - } - // uint32 _iMagical = 6; - if (this_._internal__imagical() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal__imagical()); - } - // uint32 _iClass = 9; - if (this_._internal__iclass() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal__iclass()); - } - // sint32 _iCurs = 10; - if (this_._internal__icurs() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__icurs()); - } - // sint32 _iValue = 11; - if (this_._internal__ivalue() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__ivalue()); - } - // sint32 _iMinDam = 12; - if (this_._internal__imindam() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__imindam()); - } - // sint32 _iMaxDam = 13; - if (this_._internal__imaxdam() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__imaxdam()); - } - // sint32 _iAC = 14; - if (this_._internal__iac() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__iac()); - } - // sint32 _iFlags = 15; - if (this_._internal__iflags() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__iflags()); - } - // sint32 _iMiscId = 16; - if (this_._internal__imiscid() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__imiscid()); - } - // sint32 _iSpell = 17; - if (this_._internal__ispell() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ispell()); - } - // sint32 _iCharges = 18; - if (this_._internal__icharges() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__icharges()); - } - // sint32 _iMaxCharges = 19; - if (this_._internal__imaxcharges() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__imaxcharges()); - } - // sint32 _iDurability = 20; - if (this_._internal__idurability() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__idurability()); - } - // sint32 _iMaxDur = 21; - if (this_._internal__imaxdur() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__imaxdur()); - } - // sint32 _iPLDam = 22; - if (this_._internal__ipldam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipldam()); - } - // sint32 _iPLToHit = 23; - if (this_._internal__ipltohit() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipltohit()); - } - // sint32 _iPLAC = 24; - if (this_._internal__iplac() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplac()); - } - // sint32 _iPLStr = 25; - if (this_._internal__iplstr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplstr()); - } - // sint32 _iPLMag = 26; - if (this_._internal__iplmag() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplmag()); - } - // bool _iIdentified = 5; - if (this_._internal__iidentified() != 0) { - total_size += 2; - } - // bool _iStatFlag = 47; - if (this_._internal__istatflag() != 0) { - total_size += 3; - } - // sint32 _iPLDex = 27; - if (this_._internal__ipldex() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipldex()); - } - // sint32 _iPLVit = 28; - if (this_._internal__iplvit() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplvit()); - } - // sint32 _iPLFR = 29; - if (this_._internal__iplfr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplfr()); - } - // sint32 _iPLLR = 30; - if (this_._internal__ipllr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipllr()); - } - // sint32 _iPLMR = 31; - if (this_._internal__iplmr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplmr()); - } - // sint32 _iPLMana = 32; - if (this_._internal__iplmana() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplmana()); - } - // sint32 _iPLHP = 33; - if (this_._internal__iplhp() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplhp()); - } - // sint32 _iPLDamMod = 34; - if (this_._internal__ipldammod() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipldammod()); - } - // sint32 _iPLGetHit = 35; - if (this_._internal__iplgethit() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iplgethit()); - } - // sint32 _iPLLight = 36; - if (this_._internal__ipllight() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ipllight()); - } - // sint32 _iSplLvlAdd = 37; - if (this_._internal__ispllvladd() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ispllvladd()); - } - // sint32 _iFMinDam = 38; - if (this_._internal__ifmindam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ifmindam()); - } - // sint32 _iFMaxDam = 39; - if (this_._internal__ifmaxdam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ifmaxdam()); - } - // sint32 _iLMinDam = 40; - if (this_._internal__ilmindam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ilmindam()); - } - // sint32 _iLMaxDam = 41; - if (this_._internal__ilmaxdam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__ilmaxdam()); - } - // sint32 _iPrePower = 42; - if (this_._internal__iprepower() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iprepower()); - } - // sint32 _iSufPower = 43; - if (this_._internal__isufpower() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__isufpower()); - } - // sint32 _iMinStr = 44; - if (this_._internal__iminstr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iminstr()); - } - // sint32 _iMinMag = 45; - if (this_._internal__iminmag() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__iminmag()); - } - // sint32 _iMinDex = 46; - if (this_._internal__imindex() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__imindex()); - } - // sint32 IDidx = 48; - if (this_._internal_ididx() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal_ididx()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ItemData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.ItemData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (!from._internal__iname().empty()) { - _this->_internal_set__iname(from._internal__iname()); - } - if (!from._internal__iiname().empty()) { - _this->_internal_set__iiname(from._internal__iiname()); - } - if (from._internal_id() != 0) { - _this->_impl_.id_ = from._impl_.id_; - } - if (from._internal__itype() != 0) { - _this->_impl_._itype_ = from._impl_._itype_; - } - if (from._internal__ix() != 0) { - _this->_impl_._ix_ = from._impl_._ix_; - } - if (from._internal__iy() != 0) { - _this->_impl_._iy_ = from._impl_._iy_; - } - if (from._internal__imagical() != 0) { - _this->_impl_._imagical_ = from._impl_._imagical_; - } - if (from._internal__iclass() != 0) { - _this->_impl_._iclass_ = from._impl_._iclass_; - } - if (from._internal__icurs() != 0) { - _this->_impl_._icurs_ = from._impl_._icurs_; - } - if (from._internal__ivalue() != 0) { - _this->_impl_._ivalue_ = from._impl_._ivalue_; - } - if (from._internal__imindam() != 0) { - _this->_impl_._imindam_ = from._impl_._imindam_; - } - if (from._internal__imaxdam() != 0) { - _this->_impl_._imaxdam_ = from._impl_._imaxdam_; - } - if (from._internal__iac() != 0) { - _this->_impl_._iac_ = from._impl_._iac_; - } - if (from._internal__iflags() != 0) { - _this->_impl_._iflags_ = from._impl_._iflags_; - } - if (from._internal__imiscid() != 0) { - _this->_impl_._imiscid_ = from._impl_._imiscid_; - } - if (from._internal__ispell() != 0) { - _this->_impl_._ispell_ = from._impl_._ispell_; - } - if (from._internal__icharges() != 0) { - _this->_impl_._icharges_ = from._impl_._icharges_; - } - if (from._internal__imaxcharges() != 0) { - _this->_impl_._imaxcharges_ = from._impl_._imaxcharges_; - } - if (from._internal__idurability() != 0) { - _this->_impl_._idurability_ = from._impl_._idurability_; - } - if (from._internal__imaxdur() != 0) { - _this->_impl_._imaxdur_ = from._impl_._imaxdur_; - } - if (from._internal__ipldam() != 0) { - _this->_impl_._ipldam_ = from._impl_._ipldam_; - } - if (from._internal__ipltohit() != 0) { - _this->_impl_._ipltohit_ = from._impl_._ipltohit_; - } - if (from._internal__iplac() != 0) { - _this->_impl_._iplac_ = from._impl_._iplac_; - } - if (from._internal__iplstr() != 0) { - _this->_impl_._iplstr_ = from._impl_._iplstr_; - } - if (from._internal__iplmag() != 0) { - _this->_impl_._iplmag_ = from._impl_._iplmag_; - } - if (from._internal__iidentified() != 0) { - _this->_impl_._iidentified_ = from._impl_._iidentified_; - } - if (from._internal__istatflag() != 0) { - _this->_impl_._istatflag_ = from._impl_._istatflag_; - } - if (from._internal__ipldex() != 0) { - _this->_impl_._ipldex_ = from._impl_._ipldex_; - } - if (from._internal__iplvit() != 0) { - _this->_impl_._iplvit_ = from._impl_._iplvit_; - } - if (from._internal__iplfr() != 0) { - _this->_impl_._iplfr_ = from._impl_._iplfr_; - } - if (from._internal__ipllr() != 0) { - _this->_impl_._ipllr_ = from._impl_._ipllr_; - } - if (from._internal__iplmr() != 0) { - _this->_impl_._iplmr_ = from._impl_._iplmr_; - } - if (from._internal__iplmana() != 0) { - _this->_impl_._iplmana_ = from._impl_._iplmana_; - } - if (from._internal__iplhp() != 0) { - _this->_impl_._iplhp_ = from._impl_._iplhp_; - } - if (from._internal__ipldammod() != 0) { - _this->_impl_._ipldammod_ = from._impl_._ipldammod_; - } - if (from._internal__iplgethit() != 0) { - _this->_impl_._iplgethit_ = from._impl_._iplgethit_; - } - if (from._internal__ipllight() != 0) { - _this->_impl_._ipllight_ = from._impl_._ipllight_; - } - if (from._internal__ispllvladd() != 0) { - _this->_impl_._ispllvladd_ = from._impl_._ispllvladd_; - } - if (from._internal__ifmindam() != 0) { - _this->_impl_._ifmindam_ = from._impl_._ifmindam_; - } - if (from._internal__ifmaxdam() != 0) { - _this->_impl_._ifmaxdam_ = from._impl_._ifmaxdam_; - } - if (from._internal__ilmindam() != 0) { - _this->_impl_._ilmindam_ = from._impl_._ilmindam_; - } - if (from._internal__ilmaxdam() != 0) { - _this->_impl_._ilmaxdam_ = from._impl_._ilmaxdam_; - } - if (from._internal__iprepower() != 0) { - _this->_impl_._iprepower_ = from._impl_._iprepower_; - } - if (from._internal__isufpower() != 0) { - _this->_impl_._isufpower_ = from._impl_._isufpower_; - } - if (from._internal__iminstr() != 0) { - _this->_impl_._iminstr_ = from._impl_._iminstr_; - } - if (from._internal__iminmag() != 0) { - _this->_impl_._iminmag_ = from._impl_._iminmag_; - } - if (from._internal__imindex() != 0) { - _this->_impl_._imindex_ = from._impl_._imindex_; - } - if (from._internal_ididx() != 0) { - _this->_impl_.ididx_ = from._impl_.ididx_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ItemData::CopyFrom(const ItemData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.ItemData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ItemData::InternalSwap(ItemData* PROTOBUF_RESTRICT other) { - using std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._iname_, &other->_impl_._iname_, arena); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._iiname_, &other->_impl_._iiname_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(ItemData, _impl_.ididx_) - + sizeof(ItemData::_impl_.ididx_) - - PROTOBUF_FIELD_OFFSET(ItemData, _impl_.id_)>( - reinterpret_cast(&_impl_.id_), - reinterpret_cast(&other->_impl_.id_)); -} - -// =================================================================== - -class PlayerData::_Internal { - public: -}; - -PlayerData::PlayerData(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.data.PlayerData) -} -inline PROTOBUF_NDEBUG_INLINE PlayerData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::data::PlayerData& from_msg) - : _pspllvl_{visibility, arena, from._pspllvl_}, - __pspllvl_cached_byte_size_{0}, - invbody_{visibility, arena, from.invbody_}, - _invbody_cached_byte_size_{0}, - invlist_{visibility, arena, from.invlist_}, - _invlist_cached_byte_size_{0}, - invgrid_{visibility, arena, from.invgrid_}, - _invgrid_cached_byte_size_{0}, - spdlist_{visibility, arena, from.spdlist_}, - _spdlist_cached_byte_size_{0}, - _pname_(arena, from._pname_), - _cached_size_{0} {} - -PlayerData::PlayerData( - ::google::protobuf::Arena* arena, - const PlayerData& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - PlayerData* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, _pmode_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, _pmode_), - offsetof(Impl_, pmanashield_) - - offsetof(Impl_, _pmode_) + - sizeof(Impl_::pmanashield_)); - - // @@protoc_insertion_point(copy_constructor:dapi.data.PlayerData) -} -inline PROTOBUF_NDEBUG_INLINE PlayerData::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _pspllvl_{visibility, arena}, - __pspllvl_cached_byte_size_{0}, - invbody_{visibility, arena}, - _invbody_cached_byte_size_{0}, - invlist_{visibility, arena}, - _invlist_cached_byte_size_{0}, - invgrid_{visibility, arena}, - _invgrid_cached_byte_size_{0}, - spdlist_{visibility, arena}, - _spdlist_cached_byte_size_{0}, - _pname_(arena), - _cached_size_{0} {} - -inline void PlayerData::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, _pmode_), - 0, - offsetof(Impl_, pmanashield_) - - offsetof(Impl_, _pmode_) + - sizeof(Impl_::pmanashield_)); -} -PlayerData::~PlayerData() { - // @@protoc_insertion_point(destructor:dapi.data.PlayerData) - SharedDtor(*this); -} -inline void PlayerData::SharedDtor(MessageLite& self) { - PlayerData& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_._pname_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* PlayerData::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) PlayerData(arena); -} -constexpr auto PlayerData::InternalNewImpl_() { - constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_) + - decltype(PlayerData::_impl_._pspllvl_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invbody_) + - decltype(PlayerData::_impl_.invbody_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invlist_) + - decltype(PlayerData::_impl_.invlist_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invgrid_) + - decltype(PlayerData::_impl_.invgrid_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.spdlist_) + - decltype(PlayerData::_impl_.spdlist_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - }); - if (arena_bits.has_value()) { - return ::google::protobuf::internal::MessageCreator::CopyInit( - sizeof(PlayerData), alignof(PlayerData), *arena_bits); - } else { - return ::google::protobuf::internal::MessageCreator(&PlayerData::PlacementNew_, - sizeof(PlayerData), - alignof(PlayerData)); - } -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> PlayerData::_class_data_ = { - { - &_PlayerData_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &PlayerData::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &PlayerData::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &PlayerData::ByteSizeLong, - &PlayerData::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._cached_size_), - true, - }, - "dapi.data.PlayerData", -}; -const ::google::protobuf::internal::ClassData* PlayerData::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<5, 50, 0, 83, 9> PlayerData::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 50, 248, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 0, // skipmap - offsetof(decltype(_table_), field_entries), - 50, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::data::PlayerData>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // sint32 _pmode = 1; - {::_pbi::TcParser::FastZ32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_)}}, - // sint32 pnum = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pnum_)}}, - // sint32 plrlevel = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.plrlevel_)}}, - // sint32 _px = 4; - {::_pbi::TcParser::FastZ32S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._px_)}}, - // sint32 _py = 5; - {::_pbi::TcParser::FastZ32S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._py_)}}, - // sint32 _pfutx = 6; - {::_pbi::TcParser::FastZ32S1, - {48, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfutx_)}}, - // sint32 _pfuty = 7; - {::_pbi::TcParser::FastZ32S1, - {56, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfuty_)}}, - // sint32 _pdir = 8; - {::_pbi::TcParser::FastZ32S1, - {64, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdir_)}}, - // sint32 _pRSpell = 9; - {::_pbi::TcParser::FastZ32S1, - {72, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspell_)}}, - // uint32 _pRsplType = 10; - {::_pbi::TcParser::FastV32S1, - {80, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspltype_)}}, - // repeated uint32 _pSplLvl = 11; - {::_pbi::TcParser::FastV32P1, - {90, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_)}}, - // uint64 _pMemSpells = 12; - {::_pbi::TcParser::FastV64S1, - {96, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmemspells_)}}, - // uint64 _pAblSpells = 13; - {::_pbi::TcParser::FastV64S1, - {104, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pablspells_)}}, - // uint64 _pScrlSpells = 14; - {::_pbi::TcParser::FastV64S1, - {112, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pscrlspells_)}}, - // string _pName = 15; - {::_pbi::TcParser::FastUS1, - {122, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pname_)}}, - // uint32 _pClass = 16; - {::_pbi::TcParser::FastV32S2, - {384, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pclass_)}}, - // uint32 _pStrength = 17; - {::_pbi::TcParser::FastV32S2, - {392, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstrength_)}}, - // uint32 _pBaseStr = 18; - {::_pbi::TcParser::FastV32S2, - {400, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasestr_)}}, - // uint32 _pMagic = 19; - {::_pbi::TcParser::FastV32S2, - {408, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagic_)}}, - // uint32 _pBaseMag = 20; - {::_pbi::TcParser::FastV32S2, - {416, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasemag_)}}, - // uint32 _pDexterity = 21; - {::_pbi::TcParser::FastV32S2, - {424, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdexterity_)}}, - // uint32 _pBaseDex = 22; - {::_pbi::TcParser::FastV32S2, - {432, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasedex_)}}, - // uint32 _pVitality = 23; - {::_pbi::TcParser::FastV32S2, - {440, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pvitality_)}}, - // uint32 _pBaseVit = 24; - {::_pbi::TcParser::FastV32S2, - {448, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasevit_)}}, - // uint32 _pStatPts = 25; - {::_pbi::TcParser::FastV32S2, - {456, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstatpts_)}}, - // uint32 _pDamageMod = 26; - {::_pbi::TcParser::FastV32S2, - {464, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdamagemod_)}}, - // uint32 _pHitPoints = 27; - {::_pbi::TcParser::FastV32S2, - {472, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._phitpoints_)}}, - // uint32 _pMaxHP = 28; - {::_pbi::TcParser::FastV32S2, - {480, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxhp_)}}, - // sint32 _pMana = 29; - {::_pbi::TcParser::FastZ32S2, - {488, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmana_)}}, - // uint32 _pMaxMana = 30; - {::_pbi::TcParser::FastV32S2, - {496, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxmana_)}}, - // uint32 _pLevel = 31; - {::_pbi::TcParser::FastV32S2, - {504, 63, 0, PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plevel_)}}, - }}, {{ - 33, 0, 2, - 0, 32, 65532, 48, - 65535, 65535 - }}, {{ - // sint32 _pmode = 1; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 pnum = 2; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pnum_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 plrlevel = 3; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.plrlevel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _px = 4; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._px_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _py = 5; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._py_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _pfutx = 6; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfutx_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _pfuty = 7; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfuty_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _pdir = 8; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdir_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 _pRSpell = 9; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspell_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // uint32 _pRsplType = 10; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._prspltype_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // repeated uint32 _pSplLvl = 11; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pspllvl_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, - // uint64 _pMemSpells = 12; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmemspells_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, - // uint64 _pAblSpells = 13; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pablspells_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, - // uint64 _pScrlSpells = 14; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pscrlspells_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt64)}, - // string _pName = 15; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pname_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 _pClass = 16; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pclass_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pStrength = 17; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstrength_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pBaseStr = 18; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasestr_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pMagic = 19; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagic_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pBaseMag = 20; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasemag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pDexterity = 21; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdexterity_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pBaseDex = 22; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasedex_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pVitality = 23; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pvitality_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pBaseVit = 24; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pbasevit_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pStatPts = 25; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pstatpts_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pDamageMod = 26; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pdamagemod_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pHitPoints = 27; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._phitpoints_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pMaxHP = 28; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxhp_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 _pMana = 29; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmana_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // uint32 _pMaxMana = 30; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmaxmana_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pLevel = 31; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plevel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pExperience = 32; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pexperience_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pArmorClass = 33; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._parmorclass_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pMagResist = 34; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmagresist_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pFireResist = 35; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pfireresist_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pLightResist = 36; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._plightresist_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pGold = 37; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pgold_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // repeated sint32 InvBody = 38; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invbody_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, - // repeated sint32 InvList = 39; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invlist_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, - // repeated sint32 InvGrid = 40; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.invgrid_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, - // repeated sint32 SpdList = 41; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.spdlist_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedSInt32)}, - // sint32 HoldItem = 42; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.holditem_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // uint32 _pIAC = 43; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._piac_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIMinDam = 44; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pimindam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIMaxDam = 45; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pimaxdam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIBonusDam = 46; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusdam_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIBonusToHit = 47; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonustohit_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIBonusAC = 48; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusac_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 _pIBonusDamMod = 49; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pibonusdammod_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // bool pManaShield = 50; - {PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pmanashield_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - }}, - // no aux_entries - {{ - "\24\0\0\0\0\0\0\0\0\0\0\0\0\0\0\6\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" - "dapi.data.PlayerData" - "_pName" - }}, -}; - -PROTOBUF_NOINLINE void PlayerData::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.data.PlayerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_._pspllvl_.Clear(); - _impl_.invbody_.Clear(); - _impl_.invlist_.Clear(); - _impl_.invgrid_.Clear(); - _impl_.spdlist_.Clear(); - _impl_._pname_.ClearToEmpty(); - ::memset(&_impl_._pmode_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.pmanashield_) - - reinterpret_cast(&_impl_._pmode_)) + sizeof(_impl_.pmanashield_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* PlayerData::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const PlayerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* PlayerData::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const PlayerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.data.PlayerData) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // sint32 _pmode = 1; - if (this_._internal__pmode() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 1, this_._internal__pmode(), target); - } - - // sint32 pnum = 2; - if (this_._internal_pnum() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_pnum(), target); - } - - // sint32 plrlevel = 3; - if (this_._internal_plrlevel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_plrlevel(), target); - } - - // sint32 _px = 4; - if (this_._internal__px() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 4, this_._internal__px(), target); - } - - // sint32 _py = 5; - if (this_._internal__py() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 5, this_._internal__py(), target); - } - - // sint32 _pfutx = 6; - if (this_._internal__pfutx() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 6, this_._internal__pfutx(), target); - } - - // sint32 _pfuty = 7; - if (this_._internal__pfuty() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 7, this_._internal__pfuty(), target); - } - - // sint32 _pdir = 8; - if (this_._internal__pdir() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 8, this_._internal__pdir(), target); - } - - // sint32 _pRSpell = 9; - if (this_._internal__prspell() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 9, this_._internal__prspell(), target); - } - - // uint32 _pRsplType = 10; - if (this_._internal__prspltype() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 10, this_._internal__prspltype(), target); - } - - // repeated uint32 _pSplLvl = 11; - { - int byte_size = this_._impl_.__pspllvl_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 11, this_._internal__pspllvl(), byte_size, target); - } - } - - // uint64 _pMemSpells = 12; - if (this_._internal__pmemspells() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 12, this_._internal__pmemspells(), target); - } - - // uint64 _pAblSpells = 13; - if (this_._internal__pablspells() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 13, this_._internal__pablspells(), target); - } - - // uint64 _pScrlSpells = 14; - if (this_._internal__pscrlspells() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt64ToArray( - 14, this_._internal__pscrlspells(), target); - } - - // string _pName = 15; - if (!this_._internal__pname().empty()) { - const std::string& _s = this_._internal__pname(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.data.PlayerData._pName"); - target = stream->WriteStringMaybeAliased(15, _s, target); - } - - // uint32 _pClass = 16; - if (this_._internal__pclass() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 16, this_._internal__pclass(), target); - } - - // uint32 _pStrength = 17; - if (this_._internal__pstrength() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 17, this_._internal__pstrength(), target); - } - - // uint32 _pBaseStr = 18; - if (this_._internal__pbasestr() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 18, this_._internal__pbasestr(), target); - } - - // uint32 _pMagic = 19; - if (this_._internal__pmagic() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 19, this_._internal__pmagic(), target); - } - - // uint32 _pBaseMag = 20; - if (this_._internal__pbasemag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 20, this_._internal__pbasemag(), target); - } - - // uint32 _pDexterity = 21; - if (this_._internal__pdexterity() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 21, this_._internal__pdexterity(), target); - } - - // uint32 _pBaseDex = 22; - if (this_._internal__pbasedex() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 22, this_._internal__pbasedex(), target); - } - - // uint32 _pVitality = 23; - if (this_._internal__pvitality() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 23, this_._internal__pvitality(), target); - } - - // uint32 _pBaseVit = 24; - if (this_._internal__pbasevit() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 24, this_._internal__pbasevit(), target); - } - - // uint32 _pStatPts = 25; - if (this_._internal__pstatpts() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 25, this_._internal__pstatpts(), target); - } - - // uint32 _pDamageMod = 26; - if (this_._internal__pdamagemod() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 26, this_._internal__pdamagemod(), target); - } - - // uint32 _pHitPoints = 27; - if (this_._internal__phitpoints() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 27, this_._internal__phitpoints(), target); - } - - // uint32 _pMaxHP = 28; - if (this_._internal__pmaxhp() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 28, this_._internal__pmaxhp(), target); - } - - // sint32 _pMana = 29; - if (this_._internal__pmana() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 29, this_._internal__pmana(), target); - } - - // uint32 _pMaxMana = 30; - if (this_._internal__pmaxmana() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 30, this_._internal__pmaxmana(), target); - } - - // uint32 _pLevel = 31; - if (this_._internal__plevel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 31, this_._internal__plevel(), target); - } - - // uint32 _pExperience = 32; - if (this_._internal__pexperience() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 32, this_._internal__pexperience(), target); - } - - // uint32 _pArmorClass = 33; - if (this_._internal__parmorclass() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 33, this_._internal__parmorclass(), target); - } - - // uint32 _pMagResist = 34; - if (this_._internal__pmagresist() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 34, this_._internal__pmagresist(), target); - } - - // uint32 _pFireResist = 35; - if (this_._internal__pfireresist() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 35, this_._internal__pfireresist(), target); - } - - // uint32 _pLightResist = 36; - if (this_._internal__plightresist() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 36, this_._internal__plightresist(), target); - } - - // uint32 _pGold = 37; - if (this_._internal__pgold() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 37, this_._internal__pgold(), target); - } - - // repeated sint32 InvBody = 38; - { - int byte_size = this_._impl_._invbody_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteSInt32Packed( - 38, this_._internal_invbody(), byte_size, target); - } - } - - // repeated sint32 InvList = 39; - { - int byte_size = this_._impl_._invlist_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteSInt32Packed( - 39, this_._internal_invlist(), byte_size, target); - } - } - - // repeated sint32 InvGrid = 40; - { - int byte_size = this_._impl_._invgrid_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteSInt32Packed( - 40, this_._internal_invgrid(), byte_size, target); - } - } - - // repeated sint32 SpdList = 41; - { - int byte_size = this_._impl_._spdlist_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteSInt32Packed( - 41, this_._internal_spdlist(), byte_size, target); - } - } - - // sint32 HoldItem = 42; - if (this_._internal_holditem() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 42, this_._internal_holditem(), target); - } - - // uint32 _pIAC = 43; - if (this_._internal__piac() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 43, this_._internal__piac(), target); - } - - // uint32 _pIMinDam = 44; - if (this_._internal__pimindam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 44, this_._internal__pimindam(), target); - } - - // uint32 _pIMaxDam = 45; - if (this_._internal__pimaxdam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 45, this_._internal__pimaxdam(), target); - } - - // uint32 _pIBonusDam = 46; - if (this_._internal__pibonusdam() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 46, this_._internal__pibonusdam(), target); - } - - // uint32 _pIBonusToHit = 47; - if (this_._internal__pibonustohit() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 47, this_._internal__pibonustohit(), target); - } - - // uint32 _pIBonusAC = 48; - if (this_._internal__pibonusac() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 48, this_._internal__pibonusac(), target); - } - - // uint32 _pIBonusDamMod = 49; - if (this_._internal__pibonusdammod() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 49, this_._internal__pibonusdammod(), target); - } - - // bool pManaShield = 50; - if (this_._internal_pmanashield() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 50, this_._internal_pmanashield(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.data.PlayerData) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t PlayerData::ByteSizeLong(const MessageLite& base) { - const PlayerData& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t PlayerData::ByteSizeLong() const { - const PlayerData& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.data.PlayerData) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // repeated uint32 _pSplLvl = 11; - { - total_size += - ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( - this_._internal__pspllvl(), 1, - this_._impl_.__pspllvl_cached_byte_size_); - } - // repeated sint32 InvBody = 38; - { - total_size += - ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( - this_._internal_invbody(), 2, - this_._impl_._invbody_cached_byte_size_); - } - // repeated sint32 InvList = 39; - { - total_size += - ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( - this_._internal_invlist(), 2, - this_._impl_._invlist_cached_byte_size_); - } - // repeated sint32 InvGrid = 40; - { - total_size += - ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( - this_._internal_invgrid(), 2, - this_._impl_._invgrid_cached_byte_size_); - } - // repeated sint32 SpdList = 41; - { - total_size += - ::_pbi::WireFormatLite::SInt32SizeWithPackedTagSize( - this_._internal_spdlist(), 2, - this_._impl_._spdlist_cached_byte_size_); - } - } - { - // string _pName = 15; - if (!this_._internal__pname().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal__pname()); - } - // sint32 _pmode = 1; - if (this_._internal__pmode() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__pmode()); - } - // sint32 pnum = 2; - if (this_._internal_pnum() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_pnum()); - } - // sint32 plrlevel = 3; - if (this_._internal_plrlevel() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_plrlevel()); - } - // sint32 _px = 4; - if (this_._internal__px() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__px()); - } - // sint32 _py = 5; - if (this_._internal__py() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__py()); - } - // sint32 _pfutx = 6; - if (this_._internal__pfutx() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__pfutx()); - } - // sint32 _pfuty = 7; - if (this_._internal__pfuty() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__pfuty()); - } - // sint32 _pdir = 8; - if (this_._internal__pdir() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__pdir()); - } - // sint32 _pRSpell = 9; - if (this_._internal__prspell() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal__prspell()); - } - // uint32 _pRsplType = 10; - if (this_._internal__prspltype() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal__prspltype()); - } - // uint64 _pMemSpells = 12; - if (this_._internal__pmemspells() != 0) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( - this_._internal__pmemspells()); - } - // uint64 _pAblSpells = 13; - if (this_._internal__pablspells() != 0) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( - this_._internal__pablspells()); - } - // uint64 _pScrlSpells = 14; - if (this_._internal__pscrlspells() != 0) { - total_size += ::_pbi::WireFormatLite::UInt64SizePlusOne( - this_._internal__pscrlspells()); - } - // uint32 _pClass = 16; - if (this_._internal__pclass() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pclass()); - } - // uint32 _pStrength = 17; - if (this_._internal__pstrength() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pstrength()); - } - // uint32 _pBaseStr = 18; - if (this_._internal__pbasestr() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pbasestr()); - } - // uint32 _pMagic = 19; - if (this_._internal__pmagic() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pmagic()); - } - // uint32 _pBaseMag = 20; - if (this_._internal__pbasemag() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pbasemag()); - } - // uint32 _pDexterity = 21; - if (this_._internal__pdexterity() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pdexterity()); - } - // uint32 _pBaseDex = 22; - if (this_._internal__pbasedex() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pbasedex()); - } - // uint32 _pVitality = 23; - if (this_._internal__pvitality() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pvitality()); - } - // uint32 _pBaseVit = 24; - if (this_._internal__pbasevit() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pbasevit()); - } - // uint32 _pStatPts = 25; - if (this_._internal__pstatpts() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pstatpts()); - } - // uint32 _pDamageMod = 26; - if (this_._internal__pdamagemod() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pdamagemod()); - } - // uint32 _pHitPoints = 27; - if (this_._internal__phitpoints() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__phitpoints()); - } - // uint32 _pMaxHP = 28; - if (this_._internal__pmaxhp() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pmaxhp()); - } - // sint32 _pMana = 29; - if (this_._internal__pmana() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal__pmana()); - } - // uint32 _pMaxMana = 30; - if (this_._internal__pmaxmana() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pmaxmana()); - } - // uint32 _pLevel = 31; - if (this_._internal__plevel() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__plevel()); - } - // uint32 _pExperience = 32; - if (this_._internal__pexperience() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pexperience()); - } - // uint32 _pArmorClass = 33; - if (this_._internal__parmorclass() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__parmorclass()); - } - // uint32 _pMagResist = 34; - if (this_._internal__pmagresist() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pmagresist()); - } - // uint32 _pFireResist = 35; - if (this_._internal__pfireresist() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pfireresist()); - } - // uint32 _pLightResist = 36; - if (this_._internal__plightresist() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__plightresist()); - } - // uint32 _pGold = 37; - if (this_._internal__pgold() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pgold()); - } - // sint32 HoldItem = 42; - if (this_._internal_holditem() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::SInt32Size( - this_._internal_holditem()); - } - // uint32 _pIAC = 43; - if (this_._internal__piac() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__piac()); - } - // uint32 _pIMinDam = 44; - if (this_._internal__pimindam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pimindam()); - } - // uint32 _pIMaxDam = 45; - if (this_._internal__pimaxdam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pimaxdam()); - } - // uint32 _pIBonusDam = 46; - if (this_._internal__pibonusdam() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pibonusdam()); - } - // uint32 _pIBonusToHit = 47; - if (this_._internal__pibonustohit() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pibonustohit()); - } - // uint32 _pIBonusAC = 48; - if (this_._internal__pibonusac() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pibonusac()); - } - // uint32 _pIBonusDamMod = 49; - if (this_._internal__pibonusdammod() != 0) { - total_size += 2 + ::_pbi::WireFormatLite::UInt32Size( - this_._internal__pibonusdammod()); - } - // bool pManaShield = 50; - if (this_._internal_pmanashield() != 0) { - total_size += 3; - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void PlayerData::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.data.PlayerData) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_mutable__pspllvl()->MergeFrom(from._internal__pspllvl()); - _this->_internal_mutable_invbody()->MergeFrom(from._internal_invbody()); - _this->_internal_mutable_invlist()->MergeFrom(from._internal_invlist()); - _this->_internal_mutable_invgrid()->MergeFrom(from._internal_invgrid()); - _this->_internal_mutable_spdlist()->MergeFrom(from._internal_spdlist()); - if (!from._internal__pname().empty()) { - _this->_internal_set__pname(from._internal__pname()); - } - if (from._internal__pmode() != 0) { - _this->_impl_._pmode_ = from._impl_._pmode_; - } - if (from._internal_pnum() != 0) { - _this->_impl_.pnum_ = from._impl_.pnum_; - } - if (from._internal_plrlevel() != 0) { - _this->_impl_.plrlevel_ = from._impl_.plrlevel_; - } - if (from._internal__px() != 0) { - _this->_impl_._px_ = from._impl_._px_; - } - if (from._internal__py() != 0) { - _this->_impl_._py_ = from._impl_._py_; - } - if (from._internal__pfutx() != 0) { - _this->_impl_._pfutx_ = from._impl_._pfutx_; - } - if (from._internal__pfuty() != 0) { - _this->_impl_._pfuty_ = from._impl_._pfuty_; - } - if (from._internal__pdir() != 0) { - _this->_impl_._pdir_ = from._impl_._pdir_; - } - if (from._internal__prspell() != 0) { - _this->_impl_._prspell_ = from._impl_._prspell_; - } - if (from._internal__prspltype() != 0) { - _this->_impl_._prspltype_ = from._impl_._prspltype_; - } - if (from._internal__pmemspells() != 0) { - _this->_impl_._pmemspells_ = from._impl_._pmemspells_; - } - if (from._internal__pablspells() != 0) { - _this->_impl_._pablspells_ = from._impl_._pablspells_; - } - if (from._internal__pscrlspells() != 0) { - _this->_impl_._pscrlspells_ = from._impl_._pscrlspells_; - } - if (from._internal__pclass() != 0) { - _this->_impl_._pclass_ = from._impl_._pclass_; - } - if (from._internal__pstrength() != 0) { - _this->_impl_._pstrength_ = from._impl_._pstrength_; - } - if (from._internal__pbasestr() != 0) { - _this->_impl_._pbasestr_ = from._impl_._pbasestr_; - } - if (from._internal__pmagic() != 0) { - _this->_impl_._pmagic_ = from._impl_._pmagic_; - } - if (from._internal__pbasemag() != 0) { - _this->_impl_._pbasemag_ = from._impl_._pbasemag_; - } - if (from._internal__pdexterity() != 0) { - _this->_impl_._pdexterity_ = from._impl_._pdexterity_; - } - if (from._internal__pbasedex() != 0) { - _this->_impl_._pbasedex_ = from._impl_._pbasedex_; - } - if (from._internal__pvitality() != 0) { - _this->_impl_._pvitality_ = from._impl_._pvitality_; - } - if (from._internal__pbasevit() != 0) { - _this->_impl_._pbasevit_ = from._impl_._pbasevit_; - } - if (from._internal__pstatpts() != 0) { - _this->_impl_._pstatpts_ = from._impl_._pstatpts_; - } - if (from._internal__pdamagemod() != 0) { - _this->_impl_._pdamagemod_ = from._impl_._pdamagemod_; - } - if (from._internal__phitpoints() != 0) { - _this->_impl_._phitpoints_ = from._impl_._phitpoints_; - } - if (from._internal__pmaxhp() != 0) { - _this->_impl_._pmaxhp_ = from._impl_._pmaxhp_; - } - if (from._internal__pmana() != 0) { - _this->_impl_._pmana_ = from._impl_._pmana_; - } - if (from._internal__pmaxmana() != 0) { - _this->_impl_._pmaxmana_ = from._impl_._pmaxmana_; - } - if (from._internal__plevel() != 0) { - _this->_impl_._plevel_ = from._impl_._plevel_; - } - if (from._internal__pexperience() != 0) { - _this->_impl_._pexperience_ = from._impl_._pexperience_; - } - if (from._internal__parmorclass() != 0) { - _this->_impl_._parmorclass_ = from._impl_._parmorclass_; - } - if (from._internal__pmagresist() != 0) { - _this->_impl_._pmagresist_ = from._impl_._pmagresist_; - } - if (from._internal__pfireresist() != 0) { - _this->_impl_._pfireresist_ = from._impl_._pfireresist_; - } - if (from._internal__plightresist() != 0) { - _this->_impl_._plightresist_ = from._impl_._plightresist_; - } - if (from._internal__pgold() != 0) { - _this->_impl_._pgold_ = from._impl_._pgold_; - } - if (from._internal_holditem() != 0) { - _this->_impl_.holditem_ = from._impl_.holditem_; - } - if (from._internal__piac() != 0) { - _this->_impl_._piac_ = from._impl_._piac_; - } - if (from._internal__pimindam() != 0) { - _this->_impl_._pimindam_ = from._impl_._pimindam_; - } - if (from._internal__pimaxdam() != 0) { - _this->_impl_._pimaxdam_ = from._impl_._pimaxdam_; - } - if (from._internal__pibonusdam() != 0) { - _this->_impl_._pibonusdam_ = from._impl_._pibonusdam_; - } - if (from._internal__pibonustohit() != 0) { - _this->_impl_._pibonustohit_ = from._impl_._pibonustohit_; - } - if (from._internal__pibonusac() != 0) { - _this->_impl_._pibonusac_ = from._impl_._pibonusac_; - } - if (from._internal__pibonusdammod() != 0) { - _this->_impl_._pibonusdammod_ = from._impl_._pibonusdammod_; - } - if (from._internal_pmanashield() != 0) { - _this->_impl_.pmanashield_ = from._impl_.pmanashield_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void PlayerData::CopyFrom(const PlayerData& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.data.PlayerData) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void PlayerData::InternalSwap(PlayerData* PROTOBUF_RESTRICT other) { - using std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_._pspllvl_.InternalSwap(&other->_impl_._pspllvl_); - _impl_.invbody_.InternalSwap(&other->_impl_.invbody_); - _impl_.invlist_.InternalSwap(&other->_impl_.invlist_); - _impl_.invgrid_.InternalSwap(&other->_impl_.invgrid_); - _impl_.spdlist_.InternalSwap(&other->_impl_.spdlist_); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_._pname_, &other->_impl_._pname_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_.pmanashield_) - + sizeof(PlayerData::_impl_.pmanashield_) - - PROTOBUF_FIELD_OFFSET(PlayerData, _impl_._pmode_)>( - reinterpret_cast(&_impl_._pmode_), - reinterpret_cast(&other->_impl_._pmode_)); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace data -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google -// @@protoc_insertion_point(global_scope) -#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/data.pb.h b/Source/dapi/Backend/Messages/generated/data.pb.h deleted file mode 100644 index edeacb97c..000000000 --- a/Source/dapi/Backend/Messages/generated/data.pb.h +++ /dev/null @@ -1,6992 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: data.proto -// Protobuf C++ Version: 5.29.3 - -#ifndef data_2eproto_2epb_2eh -#define data_2eproto_2epb_2eh - -#include -#include -#include -#include - -#include "google/protobuf/runtime_version.h" -#if PROTOBUF_VERSION != 5029003 -#error "Protobuf C++ gencode is built with an incompatible version of" -#error "Protobuf C++ headers/runtime. See" -#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" -#endif -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/arena.h" -#include "google/protobuf/arenastring.h" -#include "google/protobuf/generated_message_tctable_decl.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/metadata_lite.h" -#include "google/protobuf/message_lite.h" -#include "google/protobuf/repeated_field.h" // IWYU pragma: export -#include "google/protobuf/extension_set.h" // IWYU pragma: export -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" - -#define PROTOBUF_INTERNAL_EXPORT_data_2eproto - -namespace google { -namespace protobuf { -namespace internal { -template -::absl::string_view GetAnyMessageName(); -} // namespace internal -} // namespace protobuf -} // namespace google - -// Internal implementation detail -- do not use these members. -struct TableStruct_data_2eproto { - static const ::uint32_t offsets[]; -}; -namespace dapi { -namespace data { -class ItemData; -struct ItemDataDefaultTypeInternal; -extern ItemDataDefaultTypeInternal _ItemData_default_instance_; -class MissileData; -struct MissileDataDefaultTypeInternal; -extern MissileDataDefaultTypeInternal _MissileData_default_instance_; -class MonsterData; -struct MonsterDataDefaultTypeInternal; -extern MonsterDataDefaultTypeInternal _MonsterData_default_instance_; -class ObjectData; -struct ObjectDataDefaultTypeInternal; -extern ObjectDataDefaultTypeInternal _ObjectData_default_instance_; -class PlayerData; -struct PlayerDataDefaultTypeInternal; -extern PlayerDataDefaultTypeInternal _PlayerData_default_instance_; -class PortalData; -struct PortalDataDefaultTypeInternal; -extern PortalDataDefaultTypeInternal _PortalData_default_instance_; -class QuestData; -struct QuestDataDefaultTypeInternal; -extern QuestDataDefaultTypeInternal _QuestData_default_instance_; -class TileData; -struct TileDataDefaultTypeInternal; -extern TileDataDefaultTypeInternal _TileData_default_instance_; -class TownerData; -struct TownerDataDefaultTypeInternal; -extern TownerDataDefaultTypeInternal _TownerData_default_instance_; -class TriggerData; -struct TriggerDataDefaultTypeInternal; -extern TriggerDataDefaultTypeInternal _TriggerData_default_instance_; -} // namespace data -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google - -namespace dapi { -namespace data { - -// =================================================================== - - -// ------------------------------------------------------------------- - -class TriggerData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.TriggerData) */ { - public: - inline TriggerData() : TriggerData(nullptr) {} - ~TriggerData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(TriggerData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(TriggerData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR TriggerData( - ::google::protobuf::internal::ConstantInitialized); - - inline TriggerData(const TriggerData& from) : TriggerData(nullptr, from) {} - inline TriggerData(TriggerData&& from) noexcept - : TriggerData(nullptr, std::move(from)) {} - inline TriggerData& operator=(const TriggerData& from) { - CopyFrom(from); - return *this; - } - inline TriggerData& operator=(TriggerData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const TriggerData& default_instance() { - return *internal_default_instance(); - } - static inline const TriggerData* internal_default_instance() { - return reinterpret_cast( - &_TriggerData_default_instance_); - } - static constexpr int kIndexInFileMessages = 5; - friend void swap(TriggerData& a, TriggerData& b) { a.Swap(&b); } - inline void Swap(TriggerData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TriggerData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TriggerData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const TriggerData& from); - void MergeFrom(const TriggerData& from) { TriggerData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(TriggerData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.TriggerData"; } - - protected: - explicit TriggerData(::google::protobuf::Arena* arena); - TriggerData(::google::protobuf::Arena* arena, const TriggerData& from); - TriggerData(::google::protobuf::Arena* arena, TriggerData&& from) noexcept - : TriggerData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kLvlFieldNumber = 1, - kXFieldNumber = 2, - kYFieldNumber = 3, - kTypeFieldNumber = 4, - }; - // uint32 lvl = 1; - void clear_lvl() ; - ::uint32_t lvl() const; - void set_lvl(::uint32_t value); - - private: - ::uint32_t _internal_lvl() const; - void _internal_set_lvl(::uint32_t value); - - public: - // sint32 x = 2; - void clear_x() ; - ::int32_t x() const; - void set_x(::int32_t value); - - private: - ::int32_t _internal_x() const; - void _internal_set_x(::int32_t value); - - public: - // sint32 y = 3; - void clear_y() ; - ::int32_t y() const; - void set_y(::int32_t value); - - private: - ::int32_t _internal_y() const; - void _internal_set_y(::int32_t value); - - public: - // sint32 type = 4; - void clear_type() ; - ::int32_t type() const; - void set_type(::int32_t value); - - private: - ::int32_t _internal_type() const; - void _internal_set_type(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.TriggerData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 2, 4, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const TriggerData& from_msg); - ::uint32_t lvl_; - ::int32_t x_; - ::int32_t y_; - ::int32_t type_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class TownerData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.TownerData) */ { - public: - inline TownerData() : TownerData(nullptr) {} - ~TownerData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(TownerData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(TownerData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR TownerData( - ::google::protobuf::internal::ConstantInitialized); - - inline TownerData(const TownerData& from) : TownerData(nullptr, from) {} - inline TownerData(TownerData&& from) noexcept - : TownerData(nullptr, std::move(from)) {} - inline TownerData& operator=(const TownerData& from) { - CopyFrom(from); - return *this; - } - inline TownerData& operator=(TownerData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const TownerData& default_instance() { - return *internal_default_instance(); - } - static inline const TownerData* internal_default_instance() { - return reinterpret_cast( - &_TownerData_default_instance_); - } - static constexpr int kIndexInFileMessages = 7; - friend void swap(TownerData& a, TownerData& b) { a.Swap(&b); } - inline void Swap(TownerData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TownerData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TownerData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const TownerData& from); - void MergeFrom(const TownerData& from) { TownerData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(TownerData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.TownerData"; } - - protected: - explicit TownerData(::google::protobuf::Arena* arena); - TownerData(::google::protobuf::Arena* arena, const TownerData& from); - TownerData(::google::protobuf::Arena* arena, TownerData&& from) noexcept - : TownerData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTNameFieldNumber = 5, - kIDFieldNumber = 1, - kTtypeFieldNumber = 2, - kTxFieldNumber = 3, - kTyFieldNumber = 4, - }; - // string _tName = 5; - void clear__tname() ; - const std::string& _tname() const; - template - void set__tname(Arg_&& arg, Args_... args); - std::string* mutable__tname(); - PROTOBUF_NODISCARD std::string* release__tname(); - void set_allocated__tname(std::string* value); - - private: - const std::string& _internal__tname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set__tname( - const std::string& value); - std::string* _internal_mutable__tname(); - - 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 _ttype = 2; - void clear__ttype() ; - ::uint32_t _ttype() const; - void set__ttype(::uint32_t value); - - private: - ::uint32_t _internal__ttype() const; - void _internal_set__ttype(::uint32_t value); - - public: - // sint32 _tx = 3; - void clear__tx() ; - ::int32_t _tx() const; - void set__tx(::int32_t value); - - private: - ::int32_t _internal__tx() const; - void _internal_set__tx(::int32_t value); - - public: - // sint32 _ty = 4; - void clear__ty() ; - ::int32_t _ty() const; - void set__ty(::int32_t value); - - private: - ::int32_t _internal__ty() const; - void _internal_set__ty(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.TownerData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 3, 5, 0, - 35, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const TownerData& from_msg); - ::google::protobuf::internal::ArenaStringPtr _tname_; - ::uint32_t id_; - ::uint32_t _ttype_; - ::int32_t _tx_; - ::int32_t _ty_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class TileData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.TileData) */ { - public: - inline TileData() : TileData(nullptr) {} - ~TileData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(TileData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(TileData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR TileData( - ::google::protobuf::internal::ConstantInitialized); - - inline TileData(const TileData& from) : TileData(nullptr, from) {} - inline TileData(TileData&& from) noexcept - : TileData(nullptr, std::move(from)) {} - inline TileData& operator=(const TileData& from) { - CopyFrom(from); - return *this; - } - inline TileData& operator=(TileData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const TileData& default_instance() { - return *internal_default_instance(); - } - static inline const TileData* internal_default_instance() { - return reinterpret_cast( - &_TileData_default_instance_); - } - static constexpr int kIndexInFileMessages = 6; - friend void swap(TileData& a, TileData& b) { a.Swap(&b); } - inline void Swap(TileData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(TileData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - TileData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const TileData& from); - void MergeFrom(const TileData& from) { TileData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(TileData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.TileData"; } - - protected: - explicit TileData(::google::protobuf::Arena* arena); - TileData(::google::protobuf::Arena* arena, const TileData& from); - TileData(::google::protobuf::Arena* arena, TileData&& from) noexcept - : TileData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTypeFieldNumber = 1, - kXFieldNumber = 3, - kSolidFieldNumber = 2, - kStopMissileFieldNumber = 5, - kYFieldNumber = 4, - }; - // sint32 type = 1; - void clear_type() ; - ::int32_t type() const; - void set_type(::int32_t value); - - private: - ::int32_t _internal_type() const; - void _internal_set_type(::int32_t value); - - public: - // sint32 x = 3; - void clear_x() ; - ::int32_t x() const; - void set_x(::int32_t value); - - private: - ::int32_t _internal_x() const; - void _internal_set_x(::int32_t value); - - public: - // bool solid = 2; - void clear_solid() ; - bool solid() const; - void set_solid(bool value); - - private: - bool _internal_solid() const; - void _internal_set_solid(bool value); - - public: - // bool stopMissile = 5; - void clear_stopmissile() ; - bool stopmissile() const; - void set_stopmissile(bool value); - - private: - bool _internal_stopmissile() const; - void _internal_set_stopmissile(bool value); - - public: - // sint32 y = 4; - void clear_y() ; - ::int32_t y() const; - void set_y(::int32_t value); - - private: - ::int32_t _internal_y() const; - void _internal_set_y(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.TileData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 3, 5, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const TileData& from_msg); - ::int32_t type_; - ::int32_t x_; - bool solid_; - bool stopmissile_; - ::int32_t y_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class QuestData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.QuestData) */ { - public: - inline QuestData() : QuestData(nullptr) {} - ~QuestData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(QuestData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(QuestData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR QuestData( - ::google::protobuf::internal::ConstantInitialized); - - inline QuestData(const QuestData& from) : QuestData(nullptr, from) {} - inline QuestData(QuestData&& from) noexcept - : QuestData(nullptr, std::move(from)) {} - inline QuestData& operator=(const QuestData& from) { - CopyFrom(from); - return *this; - } - inline QuestData& operator=(QuestData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const QuestData& default_instance() { - return *internal_default_instance(); - } - static inline const QuestData* internal_default_instance() { - return reinterpret_cast( - &_QuestData_default_instance_); - } - static constexpr int kIndexInFileMessages = 0; - friend void swap(QuestData& a, QuestData& b) { a.Swap(&b); } - inline void Swap(QuestData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(QuestData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - QuestData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const QuestData& from); - void MergeFrom(const QuestData& from) { QuestData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(QuestData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.QuestData"; } - - protected: - explicit QuestData(::google::protobuf::Arena* arena); - QuestData(::google::protobuf::Arena* arena, const QuestData& from); - QuestData(::google::protobuf::Arena* arena, QuestData&& from) noexcept - : QuestData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<20> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kIdFieldNumber = 1, - kStateFieldNumber = 2, - }; - // 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 state = 2; - void clear_state() ; - ::uint32_t state() const; - void set_state(::uint32_t value); - - private: - ::uint32_t _internal_state() const; - void _internal_set_state(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.QuestData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 1, 2, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const QuestData& from_msg); - ::uint32_t id_; - ::uint32_t state_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class PortalData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.PortalData) */ { - public: - inline PortalData() : PortalData(nullptr) {} - ~PortalData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PortalData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PortalData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR PortalData( - ::google::protobuf::internal::ConstantInitialized); - - inline PortalData(const PortalData& from) : PortalData(nullptr, from) {} - inline PortalData(PortalData&& from) noexcept - : PortalData(nullptr, std::move(from)) {} - inline PortalData& operator=(const PortalData& from) { - CopyFrom(from); - return *this; - } - inline PortalData& operator=(PortalData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const PortalData& default_instance() { - return *internal_default_instance(); - } - static inline const PortalData* internal_default_instance() { - return reinterpret_cast( - &_PortalData_default_instance_); - } - static constexpr int kIndexInFileMessages = 1; - friend void swap(PortalData& a, PortalData& b) { a.Swap(&b); } - inline void Swap(PortalData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PortalData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PortalData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const PortalData& from); - void MergeFrom(const PortalData& from) { PortalData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(PortalData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.PortalData"; } - - protected: - explicit PortalData(::google::protobuf::Arena* arena); - PortalData(::google::protobuf::Arena* arena, const PortalData& from); - PortalData(::google::protobuf::Arena* arena, PortalData&& from) noexcept - : PortalData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kXFieldNumber = 1, - kYFieldNumber = 2, - kPlayerFieldNumber = 3, - }; - // uint32 x = 1; - void clear_x() ; - ::uint32_t x() const; - void set_x(::uint32_t value); - - private: - ::uint32_t _internal_x() const; - void _internal_set_x(::uint32_t value); - - public: - // uint32 y = 2; - void clear_y() ; - ::uint32_t y() const; - void set_y(::uint32_t value); - - private: - ::uint32_t _internal_y() const; - void _internal_set_y(::uint32_t value); - - public: - // uint32 player = 3; - void clear_player() ; - ::uint32_t player() const; - void set_player(::uint32_t value); - - private: - ::uint32_t _internal_player() const; - void _internal_set_player(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.PortalData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 2, 3, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const PortalData& from_msg); - ::uint32_t x_; - ::uint32_t y_; - ::uint32_t player_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class PlayerData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.PlayerData) */ { - public: - inline PlayerData() : PlayerData(nullptr) {} - ~PlayerData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(PlayerData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(PlayerData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR PlayerData( - ::google::protobuf::internal::ConstantInitialized); - - inline PlayerData(const PlayerData& from) : PlayerData(nullptr, from) {} - inline PlayerData(PlayerData&& from) noexcept - : PlayerData(nullptr, std::move(from)) {} - inline PlayerData& operator=(const PlayerData& from) { - CopyFrom(from); - return *this; - } - inline PlayerData& operator=(PlayerData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const PlayerData& default_instance() { - return *internal_default_instance(); - } - static inline const PlayerData* internal_default_instance() { - return reinterpret_cast( - &_PlayerData_default_instance_); - } - static constexpr int kIndexInFileMessages = 9; - friend void swap(PlayerData& a, PlayerData& b) { a.Swap(&b); } - inline void Swap(PlayerData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(PlayerData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - PlayerData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const PlayerData& from); - void MergeFrom(const PlayerData& from) { PlayerData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(PlayerData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.PlayerData"; } - - protected: - explicit PlayerData(::google::protobuf::Arena* arena); - PlayerData(::google::protobuf::Arena* arena, const PlayerData& from); - PlayerData(::google::protobuf::Arena* arena, PlayerData&& from) noexcept - : PlayerData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kPSplLvlFieldNumber = 11, - kInvBodyFieldNumber = 38, - kInvListFieldNumber = 39, - kInvGridFieldNumber = 40, - kSpdListFieldNumber = 41, - kPNameFieldNumber = 15, - kPmodeFieldNumber = 1, - kPnumFieldNumber = 2, - kPlrlevelFieldNumber = 3, - kPxFieldNumber = 4, - kPyFieldNumber = 5, - kPfutxFieldNumber = 6, - kPfutyFieldNumber = 7, - kPdirFieldNumber = 8, - kPRSpellFieldNumber = 9, - kPRsplTypeFieldNumber = 10, - kPMemSpellsFieldNumber = 12, - kPAblSpellsFieldNumber = 13, - kPScrlSpellsFieldNumber = 14, - kPClassFieldNumber = 16, - kPStrengthFieldNumber = 17, - kPBaseStrFieldNumber = 18, - kPMagicFieldNumber = 19, - kPBaseMagFieldNumber = 20, - kPDexterityFieldNumber = 21, - kPBaseDexFieldNumber = 22, - kPVitalityFieldNumber = 23, - kPBaseVitFieldNumber = 24, - kPStatPtsFieldNumber = 25, - kPDamageModFieldNumber = 26, - kPHitPointsFieldNumber = 27, - kPMaxHPFieldNumber = 28, - kPManaFieldNumber = 29, - kPMaxManaFieldNumber = 30, - kPLevelFieldNumber = 31, - kPExperienceFieldNumber = 32, - kPArmorClassFieldNumber = 33, - kPMagResistFieldNumber = 34, - kPFireResistFieldNumber = 35, - kPLightResistFieldNumber = 36, - kPGoldFieldNumber = 37, - kHoldItemFieldNumber = 42, - kPIACFieldNumber = 43, - kPIMinDamFieldNumber = 44, - kPIMaxDamFieldNumber = 45, - kPIBonusDamFieldNumber = 46, - kPIBonusToHitFieldNumber = 47, - kPIBonusACFieldNumber = 48, - kPIBonusDamModFieldNumber = 49, - kPManaShieldFieldNumber = 50, - }; - // repeated uint32 _pSplLvl = 11; - int _pspllvl_size() const; - private: - int _internal__pspllvl_size() const; - - public: - void clear__pspllvl() ; - ::uint32_t _pspllvl(int index) const; - void set__pspllvl(int index, ::uint32_t value); - void add__pspllvl(::uint32_t value); - const ::google::protobuf::RepeatedField<::uint32_t>& _pspllvl() const; - ::google::protobuf::RepeatedField<::uint32_t>* mutable__pspllvl(); - - private: - const ::google::protobuf::RepeatedField<::uint32_t>& _internal__pspllvl() const; - ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable__pspllvl(); - - public: - // repeated sint32 InvBody = 38; - int invbody_size() const; - private: - int _internal_invbody_size() const; - - public: - void clear_invbody() ; - ::int32_t invbody(int index) const; - void set_invbody(int index, ::int32_t value); - void add_invbody(::int32_t value); - const ::google::protobuf::RepeatedField<::int32_t>& invbody() const; - ::google::protobuf::RepeatedField<::int32_t>* mutable_invbody(); - - private: - const ::google::protobuf::RepeatedField<::int32_t>& _internal_invbody() const; - ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invbody(); - - public: - // repeated sint32 InvList = 39; - int invlist_size() const; - private: - int _internal_invlist_size() const; - - public: - void clear_invlist() ; - ::int32_t invlist(int index) const; - void set_invlist(int index, ::int32_t value); - void add_invlist(::int32_t value); - const ::google::protobuf::RepeatedField<::int32_t>& invlist() const; - ::google::protobuf::RepeatedField<::int32_t>* mutable_invlist(); - - private: - const ::google::protobuf::RepeatedField<::int32_t>& _internal_invlist() const; - ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invlist(); - - public: - // repeated sint32 InvGrid = 40; - int invgrid_size() const; - private: - int _internal_invgrid_size() const; - - public: - void clear_invgrid() ; - ::int32_t invgrid(int index) const; - void set_invgrid(int index, ::int32_t value); - void add_invgrid(::int32_t value); - const ::google::protobuf::RepeatedField<::int32_t>& invgrid() const; - ::google::protobuf::RepeatedField<::int32_t>* mutable_invgrid(); - - private: - const ::google::protobuf::RepeatedField<::int32_t>& _internal_invgrid() const; - ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_invgrid(); - - public: - // repeated sint32 SpdList = 41; - int spdlist_size() const; - private: - int _internal_spdlist_size() const; - - public: - void clear_spdlist() ; - ::int32_t spdlist(int index) const; - void set_spdlist(int index, ::int32_t value); - void add_spdlist(::int32_t value); - const ::google::protobuf::RepeatedField<::int32_t>& spdlist() const; - ::google::protobuf::RepeatedField<::int32_t>* mutable_spdlist(); - - private: - const ::google::protobuf::RepeatedField<::int32_t>& _internal_spdlist() const; - ::google::protobuf::RepeatedField<::int32_t>* _internal_mutable_spdlist(); - - public: - // string _pName = 15; - void clear__pname() ; - const std::string& _pname() const; - template - void set__pname(Arg_&& arg, Args_... args); - std::string* mutable__pname(); - PROTOBUF_NODISCARD std::string* release__pname(); - void set_allocated__pname(std::string* value); - - private: - const std::string& _internal__pname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set__pname( - const std::string& value); - std::string* _internal_mutable__pname(); - - public: - // sint32 _pmode = 1; - void clear__pmode() ; - ::int32_t _pmode() const; - void set__pmode(::int32_t value); - - private: - ::int32_t _internal__pmode() const; - void _internal_set__pmode(::int32_t value); - - public: - // sint32 pnum = 2; - void clear_pnum() ; - ::int32_t pnum() const; - void set_pnum(::int32_t value); - - private: - ::int32_t _internal_pnum() const; - void _internal_set_pnum(::int32_t value); - - public: - // sint32 plrlevel = 3; - void clear_plrlevel() ; - ::int32_t plrlevel() const; - void set_plrlevel(::int32_t value); - - private: - ::int32_t _internal_plrlevel() const; - void _internal_set_plrlevel(::int32_t value); - - public: - // sint32 _px = 4; - void clear__px() ; - ::int32_t _px() const; - void set__px(::int32_t value); - - private: - ::int32_t _internal__px() const; - void _internal_set__px(::int32_t value); - - public: - // sint32 _py = 5; - void clear__py() ; - ::int32_t _py() const; - void set__py(::int32_t value); - - private: - ::int32_t _internal__py() const; - void _internal_set__py(::int32_t value); - - public: - // sint32 _pfutx = 6; - void clear__pfutx() ; - ::int32_t _pfutx() const; - void set__pfutx(::int32_t value); - - private: - ::int32_t _internal__pfutx() const; - void _internal_set__pfutx(::int32_t value); - - public: - // sint32 _pfuty = 7; - void clear__pfuty() ; - ::int32_t _pfuty() const; - void set__pfuty(::int32_t value); - - private: - ::int32_t _internal__pfuty() const; - void _internal_set__pfuty(::int32_t value); - - public: - // sint32 _pdir = 8; - void clear__pdir() ; - ::int32_t _pdir() const; - void set__pdir(::int32_t value); - - private: - ::int32_t _internal__pdir() const; - void _internal_set__pdir(::int32_t value); - - public: - // sint32 _pRSpell = 9; - void clear__prspell() ; - ::int32_t _prspell() const; - void set__prspell(::int32_t value); - - private: - ::int32_t _internal__prspell() const; - void _internal_set__prspell(::int32_t value); - - public: - // uint32 _pRsplType = 10; - void clear__prspltype() ; - ::uint32_t _prspltype() const; - void set__prspltype(::uint32_t value); - - private: - ::uint32_t _internal__prspltype() const; - void _internal_set__prspltype(::uint32_t value); - - public: - // uint64 _pMemSpells = 12; - void clear__pmemspells() ; - ::uint64_t _pmemspells() const; - void set__pmemspells(::uint64_t value); - - private: - ::uint64_t _internal__pmemspells() const; - void _internal_set__pmemspells(::uint64_t value); - - public: - // uint64 _pAblSpells = 13; - void clear__pablspells() ; - ::uint64_t _pablspells() const; - void set__pablspells(::uint64_t value); - - private: - ::uint64_t _internal__pablspells() const; - void _internal_set__pablspells(::uint64_t value); - - public: - // uint64 _pScrlSpells = 14; - void clear__pscrlspells() ; - ::uint64_t _pscrlspells() const; - void set__pscrlspells(::uint64_t value); - - private: - ::uint64_t _internal__pscrlspells() const; - void _internal_set__pscrlspells(::uint64_t value); - - public: - // uint32 _pClass = 16; - void clear__pclass() ; - ::uint32_t _pclass() const; - void set__pclass(::uint32_t value); - - private: - ::uint32_t _internal__pclass() const; - void _internal_set__pclass(::uint32_t value); - - public: - // uint32 _pStrength = 17; - void clear__pstrength() ; - ::uint32_t _pstrength() const; - void set__pstrength(::uint32_t value); - - private: - ::uint32_t _internal__pstrength() const; - void _internal_set__pstrength(::uint32_t value); - - public: - // uint32 _pBaseStr = 18; - void clear__pbasestr() ; - ::uint32_t _pbasestr() const; - void set__pbasestr(::uint32_t value); - - private: - ::uint32_t _internal__pbasestr() const; - void _internal_set__pbasestr(::uint32_t value); - - public: - // uint32 _pMagic = 19; - void clear__pmagic() ; - ::uint32_t _pmagic() const; - void set__pmagic(::uint32_t value); - - private: - ::uint32_t _internal__pmagic() const; - void _internal_set__pmagic(::uint32_t value); - - public: - // uint32 _pBaseMag = 20; - void clear__pbasemag() ; - ::uint32_t _pbasemag() const; - void set__pbasemag(::uint32_t value); - - private: - ::uint32_t _internal__pbasemag() const; - void _internal_set__pbasemag(::uint32_t value); - - public: - // uint32 _pDexterity = 21; - void clear__pdexterity() ; - ::uint32_t _pdexterity() const; - void set__pdexterity(::uint32_t value); - - private: - ::uint32_t _internal__pdexterity() const; - void _internal_set__pdexterity(::uint32_t value); - - public: - // uint32 _pBaseDex = 22; - void clear__pbasedex() ; - ::uint32_t _pbasedex() const; - void set__pbasedex(::uint32_t value); - - private: - ::uint32_t _internal__pbasedex() const; - void _internal_set__pbasedex(::uint32_t value); - - public: - // uint32 _pVitality = 23; - void clear__pvitality() ; - ::uint32_t _pvitality() const; - void set__pvitality(::uint32_t value); - - private: - ::uint32_t _internal__pvitality() const; - void _internal_set__pvitality(::uint32_t value); - - public: - // uint32 _pBaseVit = 24; - void clear__pbasevit() ; - ::uint32_t _pbasevit() const; - void set__pbasevit(::uint32_t value); - - private: - ::uint32_t _internal__pbasevit() const; - void _internal_set__pbasevit(::uint32_t value); - - public: - // uint32 _pStatPts = 25; - void clear__pstatpts() ; - ::uint32_t _pstatpts() const; - void set__pstatpts(::uint32_t value); - - private: - ::uint32_t _internal__pstatpts() const; - void _internal_set__pstatpts(::uint32_t value); - - public: - // uint32 _pDamageMod = 26; - void clear__pdamagemod() ; - ::uint32_t _pdamagemod() const; - void set__pdamagemod(::uint32_t value); - - private: - ::uint32_t _internal__pdamagemod() const; - void _internal_set__pdamagemod(::uint32_t value); - - public: - // uint32 _pHitPoints = 27; - void clear__phitpoints() ; - ::uint32_t _phitpoints() const; - void set__phitpoints(::uint32_t value); - - private: - ::uint32_t _internal__phitpoints() const; - void _internal_set__phitpoints(::uint32_t value); - - public: - // uint32 _pMaxHP = 28; - void clear__pmaxhp() ; - ::uint32_t _pmaxhp() const; - void set__pmaxhp(::uint32_t value); - - private: - ::uint32_t _internal__pmaxhp() const; - void _internal_set__pmaxhp(::uint32_t value); - - public: - // sint32 _pMana = 29; - void clear__pmana() ; - ::int32_t _pmana() const; - void set__pmana(::int32_t value); - - private: - ::int32_t _internal__pmana() const; - void _internal_set__pmana(::int32_t value); - - public: - // uint32 _pMaxMana = 30; - void clear__pmaxmana() ; - ::uint32_t _pmaxmana() const; - void set__pmaxmana(::uint32_t value); - - private: - ::uint32_t _internal__pmaxmana() const; - void _internal_set__pmaxmana(::uint32_t value); - - public: - // uint32 _pLevel = 31; - void clear__plevel() ; - ::uint32_t _plevel() const; - void set__plevel(::uint32_t value); - - private: - ::uint32_t _internal__plevel() const; - void _internal_set__plevel(::uint32_t value); - - public: - // uint32 _pExperience = 32; - void clear__pexperience() ; - ::uint32_t _pexperience() const; - void set__pexperience(::uint32_t value); - - private: - ::uint32_t _internal__pexperience() const; - void _internal_set__pexperience(::uint32_t value); - - public: - // uint32 _pArmorClass = 33; - void clear__parmorclass() ; - ::uint32_t _parmorclass() const; - void set__parmorclass(::uint32_t value); - - private: - ::uint32_t _internal__parmorclass() const; - void _internal_set__parmorclass(::uint32_t value); - - public: - // uint32 _pMagResist = 34; - void clear__pmagresist() ; - ::uint32_t _pmagresist() const; - void set__pmagresist(::uint32_t value); - - private: - ::uint32_t _internal__pmagresist() const; - void _internal_set__pmagresist(::uint32_t value); - - public: - // uint32 _pFireResist = 35; - void clear__pfireresist() ; - ::uint32_t _pfireresist() const; - void set__pfireresist(::uint32_t value); - - private: - ::uint32_t _internal__pfireresist() const; - void _internal_set__pfireresist(::uint32_t value); - - public: - // uint32 _pLightResist = 36; - void clear__plightresist() ; - ::uint32_t _plightresist() const; - void set__plightresist(::uint32_t value); - - private: - ::uint32_t _internal__plightresist() const; - void _internal_set__plightresist(::uint32_t value); - - public: - // uint32 _pGold = 37; - void clear__pgold() ; - ::uint32_t _pgold() const; - void set__pgold(::uint32_t value); - - private: - ::uint32_t _internal__pgold() const; - void _internal_set__pgold(::uint32_t value); - - public: - // sint32 HoldItem = 42; - void clear_holditem() ; - ::int32_t holditem() const; - void set_holditem(::int32_t value); - - private: - ::int32_t _internal_holditem() const; - void _internal_set_holditem(::int32_t value); - - public: - // uint32 _pIAC = 43; - void clear__piac() ; - ::uint32_t _piac() const; - void set__piac(::uint32_t value); - - private: - ::uint32_t _internal__piac() const; - void _internal_set__piac(::uint32_t value); - - public: - // uint32 _pIMinDam = 44; - void clear__pimindam() ; - ::uint32_t _pimindam() const; - void set__pimindam(::uint32_t value); - - private: - ::uint32_t _internal__pimindam() const; - void _internal_set__pimindam(::uint32_t value); - - public: - // uint32 _pIMaxDam = 45; - void clear__pimaxdam() ; - ::uint32_t _pimaxdam() const; - void set__pimaxdam(::uint32_t value); - - private: - ::uint32_t _internal__pimaxdam() const; - void _internal_set__pimaxdam(::uint32_t value); - - public: - // uint32 _pIBonusDam = 46; - void clear__pibonusdam() ; - ::uint32_t _pibonusdam() const; - void set__pibonusdam(::uint32_t value); - - private: - ::uint32_t _internal__pibonusdam() const; - void _internal_set__pibonusdam(::uint32_t value); - - public: - // uint32 _pIBonusToHit = 47; - void clear__pibonustohit() ; - ::uint32_t _pibonustohit() const; - void set__pibonustohit(::uint32_t value); - - private: - ::uint32_t _internal__pibonustohit() const; - void _internal_set__pibonustohit(::uint32_t value); - - public: - // uint32 _pIBonusAC = 48; - void clear__pibonusac() ; - ::uint32_t _pibonusac() const; - void set__pibonusac(::uint32_t value); - - private: - ::uint32_t _internal__pibonusac() const; - void _internal_set__pibonusac(::uint32_t value); - - public: - // uint32 _pIBonusDamMod = 49; - void clear__pibonusdammod() ; - ::uint32_t _pibonusdammod() const; - void set__pibonusdammod(::uint32_t value); - - private: - ::uint32_t _internal__pibonusdammod() const; - void _internal_set__pibonusdammod(::uint32_t value); - - public: - // bool pManaShield = 50; - void clear_pmanashield() ; - bool pmanashield() const; - void set_pmanashield(bool value); - - private: - bool _internal_pmanashield() const; - void _internal_set_pmanashield(bool value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.PlayerData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 5, 50, 0, - 83, 9> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const PlayerData& from_msg); - ::google::protobuf::RepeatedField<::uint32_t> _pspllvl_; - ::google::protobuf::internal::CachedSize __pspllvl_cached_byte_size_; - ::google::protobuf::RepeatedField<::int32_t> invbody_; - ::google::protobuf::internal::CachedSize _invbody_cached_byte_size_; - ::google::protobuf::RepeatedField<::int32_t> invlist_; - ::google::protobuf::internal::CachedSize _invlist_cached_byte_size_; - ::google::protobuf::RepeatedField<::int32_t> invgrid_; - ::google::protobuf::internal::CachedSize _invgrid_cached_byte_size_; - ::google::protobuf::RepeatedField<::int32_t> spdlist_; - ::google::protobuf::internal::CachedSize _spdlist_cached_byte_size_; - ::google::protobuf::internal::ArenaStringPtr _pname_; - ::int32_t _pmode_; - ::int32_t pnum_; - ::int32_t plrlevel_; - ::int32_t _px_; - ::int32_t _py_; - ::int32_t _pfutx_; - ::int32_t _pfuty_; - ::int32_t _pdir_; - ::int32_t _prspell_; - ::uint32_t _prspltype_; - ::uint64_t _pmemspells_; - ::uint64_t _pablspells_; - ::uint64_t _pscrlspells_; - ::uint32_t _pclass_; - ::uint32_t _pstrength_; - ::uint32_t _pbasestr_; - ::uint32_t _pmagic_; - ::uint32_t _pbasemag_; - ::uint32_t _pdexterity_; - ::uint32_t _pbasedex_; - ::uint32_t _pvitality_; - ::uint32_t _pbasevit_; - ::uint32_t _pstatpts_; - ::uint32_t _pdamagemod_; - ::uint32_t _phitpoints_; - ::uint32_t _pmaxhp_; - ::int32_t _pmana_; - ::uint32_t _pmaxmana_; - ::uint32_t _plevel_; - ::uint32_t _pexperience_; - ::uint32_t _parmorclass_; - ::uint32_t _pmagresist_; - ::uint32_t _pfireresist_; - ::uint32_t _plightresist_; - ::uint32_t _pgold_; - ::int32_t holditem_; - ::uint32_t _piac_; - ::uint32_t _pimindam_; - ::uint32_t _pimaxdam_; - ::uint32_t _pibonusdam_; - ::uint32_t _pibonustohit_; - ::uint32_t _pibonusac_; - ::uint32_t _pibonusdammod_; - bool pmanashield_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class ObjectData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.ObjectData) */ { - public: - inline ObjectData() : ObjectData(nullptr) {} - ~ObjectData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ObjectData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ObjectData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ObjectData( - ::google::protobuf::internal::ConstantInitialized); - - inline ObjectData(const ObjectData& from) : ObjectData(nullptr, from) {} - inline ObjectData(ObjectData&& from) noexcept - : ObjectData(nullptr, std::move(from)) {} - inline ObjectData& operator=(const ObjectData& from) { - CopyFrom(from); - return *this; - } - inline ObjectData& operator=(ObjectData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ObjectData& default_instance() { - return *internal_default_instance(); - } - static inline const ObjectData* internal_default_instance() { - return reinterpret_cast( - &_ObjectData_default_instance_); - } - static constexpr int kIndexInFileMessages = 3; - friend void swap(ObjectData& a, ObjectData& b) { a.Swap(&b); } - inline void Swap(ObjectData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ObjectData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ObjectData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ObjectData& from); - void MergeFrom(const ObjectData& from) { ObjectData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ObjectData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.ObjectData"; } - - protected: - explicit ObjectData(::google::protobuf::Arena* arena); - ObjectData(::google::protobuf::Arena* arena, const ObjectData& from); - ObjectData(::google::protobuf::Arena* arena, ObjectData&& from) noexcept - : ObjectData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kXFieldNumber = 1, - kYFieldNumber = 2, - kTypeFieldNumber = 3, - kShrineTypeFieldNumber = 4, - kDoorStateFieldNumber = 6, - kSolidFieldNumber = 5, - kSelectableFieldNumber = 7, - kTrappedFieldNumber = 9, - kIndexFieldNumber = 8, - }; - // uint32 x = 1; - void clear_x() ; - ::uint32_t x() const; - void set_x(::uint32_t value); - - private: - ::uint32_t _internal_x() const; - void _internal_set_x(::uint32_t value); - - public: - // uint32 y = 2; - void clear_y() ; - ::uint32_t y() const; - void set_y(::uint32_t value); - - private: - ::uint32_t _internal_y() const; - void _internal_set_y(::uint32_t value); - - public: - // sint32 type = 3; - void clear_type() ; - ::int32_t type() const; - void set_type(::int32_t value); - - private: - ::int32_t _internal_type() const; - void _internal_set_type(::int32_t value); - - public: - // sint32 shrineType = 4; - void clear_shrinetype() ; - ::int32_t shrinetype() const; - void set_shrinetype(::int32_t value); - - private: - ::int32_t _internal_shrinetype() const; - void _internal_set_shrinetype(::int32_t value); - - public: - // sint32 doorState = 6; - void clear_doorstate() ; - ::int32_t doorstate() const; - void set_doorstate(::int32_t value); - - private: - ::int32_t _internal_doorstate() const; - void _internal_set_doorstate(::int32_t value); - - public: - // bool solid = 5; - void clear_solid() ; - bool solid() const; - void set_solid(bool value); - - private: - bool _internal_solid() const; - void _internal_set_solid(bool value); - - public: - // bool selectable = 7; - void clear_selectable() ; - bool selectable() const; - void set_selectable(bool value); - - private: - bool _internal_selectable() const; - void _internal_set_selectable(bool value); - - public: - // bool trapped = 9; - void clear_trapped() ; - bool trapped() const; - void set_trapped(bool value); - - private: - bool _internal_trapped() const; - void _internal_set_trapped(bool value); - - public: - // uint32 index = 8; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.ObjectData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 4, 9, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ObjectData& from_msg); - ::uint32_t x_; - ::uint32_t y_; - ::int32_t type_; - ::int32_t shrinetype_; - ::int32_t doorstate_; - bool solid_; - bool selectable_; - bool trapped_; - ::uint32_t index_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class MonsterData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.MonsterData) */ { - public: - inline MonsterData() : MonsterData(nullptr) {} - ~MonsterData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(MonsterData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(MonsterData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR MonsterData( - ::google::protobuf::internal::ConstantInitialized); - - inline MonsterData(const MonsterData& from) : MonsterData(nullptr, from) {} - inline MonsterData(MonsterData&& from) noexcept - : MonsterData(nullptr, std::move(from)) {} - inline MonsterData& operator=(const MonsterData& from) { - CopyFrom(from); - return *this; - } - inline MonsterData& operator=(MonsterData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const MonsterData& default_instance() { - return *internal_default_instance(); - } - static inline const MonsterData* internal_default_instance() { - return reinterpret_cast( - &_MonsterData_default_instance_); - } - static constexpr int kIndexInFileMessages = 4; - friend void swap(MonsterData& a, MonsterData& b) { a.Swap(&b); } - inline void Swap(MonsterData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MonsterData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MonsterData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const MonsterData& from); - void MergeFrom(const MonsterData& from) { MonsterData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(MonsterData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.MonsterData"; } - - protected: - explicit MonsterData(::google::protobuf::Arena* arena); - MonsterData(::google::protobuf::Arena* arena, const MonsterData& from); - MonsterData(::google::protobuf::Arena* arena, MonsterData&& from) noexcept - : MonsterData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kNameFieldNumber = 6, - kIndexFieldNumber = 1, - kXFieldNumber = 2, - kYFieldNumber = 3, - kFutxFieldNumber = 4, - kFutyFieldNumber = 5, - kTypeFieldNumber = 7, - kKillsFieldNumber = 8, - kModeFieldNumber = 9, - kUniqueFieldNumber = 10, - }; - // string name = 6; - void clear_name() ; - const std::string& name() const; - template - void set_name(Arg_&& arg, Args_... args); - std::string* mutable_name(); - PROTOBUF_NODISCARD std::string* release_name(); - void set_allocated_name(std::string* value); - - 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 index = 1; - void clear_index() ; - ::uint32_t index() const; - void set_index(::uint32_t value); - - private: - ::uint32_t _internal_index() const; - void _internal_set_index(::uint32_t value); - - public: - // sint32 x = 2; - void clear_x() ; - ::int32_t x() const; - void set_x(::int32_t value); - - private: - ::int32_t _internal_x() const; - void _internal_set_x(::int32_t value); - - public: - // sint32 y = 3; - void clear_y() ; - ::int32_t y() const; - void set_y(::int32_t value); - - private: - ::int32_t _internal_y() const; - void _internal_set_y(::int32_t value); - - public: - // sint32 futx = 4; - void clear_futx() ; - ::int32_t futx() const; - void set_futx(::int32_t value); - - private: - ::int32_t _internal_futx() const; - void _internal_set_futx(::int32_t value); - - public: - // sint32 futy = 5; - void clear_futy() ; - ::int32_t futy() const; - void set_futy(::int32_t value); - - private: - ::int32_t _internal_futy() const; - void _internal_set_futy(::int32_t value); - - public: - // sint32 type = 7; - void clear_type() ; - ::int32_t type() const; - void set_type(::int32_t value); - - private: - ::int32_t _internal_type() const; - void _internal_set_type(::int32_t value); - - public: - // sint32 kills = 8; - void clear_kills() ; - ::int32_t kills() const; - void set_kills(::int32_t value); - - private: - ::int32_t _internal_kills() const; - void _internal_set_kills(::int32_t value); - - public: - // sint32 mode = 9; - void clear_mode() ; - ::int32_t mode() const; - void set_mode(::int32_t value); - - private: - ::int32_t _internal_mode() const; - void _internal_set_mode(::int32_t value); - - public: - // bool unique = 10; - void clear_unique() ; - bool unique() const; - void set_unique(bool value); - - private: - bool _internal_unique() const; - void _internal_set_unique(bool value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.MonsterData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 4, 10, 0, - 42, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const MonsterData& from_msg); - ::google::protobuf::internal::ArenaStringPtr name_; - ::uint32_t index_; - ::int32_t x_; - ::int32_t y_; - ::int32_t futx_; - ::int32_t futy_; - ::int32_t type_; - ::int32_t kills_; - ::int32_t mode_; - bool unique_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class MissileData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.MissileData) */ { - public: - inline MissileData() : MissileData(nullptr) {} - ~MissileData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(MissileData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(MissileData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR MissileData( - ::google::protobuf::internal::ConstantInitialized); - - inline MissileData(const MissileData& from) : MissileData(nullptr, from) {} - inline MissileData(MissileData&& from) noexcept - : MissileData(nullptr, std::move(from)) {} - inline MissileData& operator=(const MissileData& from) { - CopyFrom(from); - return *this; - } - inline MissileData& operator=(MissileData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const MissileData& default_instance() { - return *internal_default_instance(); - } - static inline const MissileData* internal_default_instance() { - return reinterpret_cast( - &_MissileData_default_instance_); - } - static constexpr int kIndexInFileMessages = 2; - friend void swap(MissileData& a, MissileData& b) { a.Swap(&b); } - inline void Swap(MissileData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(MissileData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - MissileData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const MissileData& from); - void MergeFrom(const MissileData& from) { MissileData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(MissileData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.MissileData"; } - - protected: - explicit MissileData(::google::protobuf::Arena* arena); - MissileData(::google::protobuf::Arena* arena, const MissileData& from); - MissileData(::google::protobuf::Arena* arena, MissileData&& from) noexcept - : MissileData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kTypeFieldNumber = 1, - kXFieldNumber = 2, - kYFieldNumber = 3, - kXvelFieldNumber = 4, - kYvelFieldNumber = 5, - kSxFieldNumber = 6, - kSyFieldNumber = 7, - }; - // sint32 type = 1; - void clear_type() ; - ::int32_t type() const; - void set_type(::int32_t value); - - private: - ::int32_t _internal_type() const; - void _internal_set_type(::int32_t value); - - public: - // uint32 x = 2; - void clear_x() ; - ::uint32_t x() const; - void set_x(::uint32_t value); - - private: - ::uint32_t _internal_x() const; - void _internal_set_x(::uint32_t value); - - public: - // uint32 y = 3; - void clear_y() ; - ::uint32_t y() const; - void set_y(::uint32_t value); - - private: - ::uint32_t _internal_y() const; - void _internal_set_y(::uint32_t value); - - public: - // sint32 xvel = 4; - void clear_xvel() ; - ::int32_t xvel() const; - void set_xvel(::int32_t value); - - private: - ::int32_t _internal_xvel() const; - void _internal_set_xvel(::int32_t value); - - public: - // sint32 yvel = 5; - void clear_yvel() ; - ::int32_t yvel() const; - void set_yvel(::int32_t value); - - private: - ::int32_t _internal_yvel() const; - void _internal_set_yvel(::int32_t value); - - public: - // sint32 sx = 6; - void clear_sx() ; - ::int32_t sx() const; - void set_sx(::int32_t value); - - private: - ::int32_t _internal_sx() const; - void _internal_set_sx(::int32_t value); - - public: - // sint32 sy = 7; - void clear_sy() ; - ::int32_t sy() const; - void set_sy(::int32_t value); - - private: - ::int32_t _internal_sy() const; - void _internal_set_sy(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.MissileData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 3, 7, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const MissileData& from_msg); - ::int32_t type_; - ::uint32_t x_; - ::uint32_t y_; - ::int32_t xvel_; - ::int32_t yvel_; - ::int32_t sx_; - ::int32_t sy_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; -// ------------------------------------------------------------------- - -class ItemData final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.data.ItemData) */ { - public: - inline ItemData() : ItemData(nullptr) {} - ~ItemData() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ItemData* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ItemData)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ItemData( - ::google::protobuf::internal::ConstantInitialized); - - inline ItemData(const ItemData& from) : ItemData(nullptr, from) {} - inline ItemData(ItemData&& from) noexcept - : ItemData(nullptr, std::move(from)) {} - inline ItemData& operator=(const ItemData& from) { - CopyFrom(from); - return *this; - } - inline ItemData& operator=(ItemData&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ItemData& default_instance() { - return *internal_default_instance(); - } - static inline const ItemData* internal_default_instance() { - return reinterpret_cast( - &_ItemData_default_instance_); - } - static constexpr int kIndexInFileMessages = 8; - friend void swap(ItemData& a, ItemData& b) { a.Swap(&b); } - inline void Swap(ItemData* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ItemData* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ItemData* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ItemData& from); - void MergeFrom(const ItemData& from) { ItemData::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ItemData* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.data.ItemData"; } - - protected: - explicit ItemData(::google::protobuf::Arena* arena); - ItemData(::google::protobuf::Arena* arena, const ItemData& from); - ItemData(::google::protobuf::Arena* arena, ItemData&& from) noexcept - : ItemData(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<19> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kINameFieldNumber = 7, - kIINameFieldNumber = 8, - kIDFieldNumber = 1, - kItypeFieldNumber = 2, - kIxFieldNumber = 3, - kIyFieldNumber = 4, - kIMagicalFieldNumber = 6, - kIClassFieldNumber = 9, - kICursFieldNumber = 10, - kIValueFieldNumber = 11, - kIMinDamFieldNumber = 12, - kIMaxDamFieldNumber = 13, - kIACFieldNumber = 14, - kIFlagsFieldNumber = 15, - kIMiscIdFieldNumber = 16, - kISpellFieldNumber = 17, - kIChargesFieldNumber = 18, - kIMaxChargesFieldNumber = 19, - kIDurabilityFieldNumber = 20, - kIMaxDurFieldNumber = 21, - kIPLDamFieldNumber = 22, - kIPLToHitFieldNumber = 23, - kIPLACFieldNumber = 24, - kIPLStrFieldNumber = 25, - kIPLMagFieldNumber = 26, - kIIdentifiedFieldNumber = 5, - kIStatFlagFieldNumber = 47, - kIPLDexFieldNumber = 27, - kIPLVitFieldNumber = 28, - kIPLFRFieldNumber = 29, - kIPLLRFieldNumber = 30, - kIPLMRFieldNumber = 31, - kIPLManaFieldNumber = 32, - kIPLHPFieldNumber = 33, - kIPLDamModFieldNumber = 34, - kIPLGetHitFieldNumber = 35, - kIPLLightFieldNumber = 36, - kISplLvlAddFieldNumber = 37, - kIFMinDamFieldNumber = 38, - kIFMaxDamFieldNumber = 39, - kILMinDamFieldNumber = 40, - kILMaxDamFieldNumber = 41, - kIPrePowerFieldNumber = 42, - kISufPowerFieldNumber = 43, - kIMinStrFieldNumber = 44, - kIMinMagFieldNumber = 45, - kIMinDexFieldNumber = 46, - kIDidxFieldNumber = 48, - }; - // string _iName = 7; - void clear__iname() ; - const std::string& _iname() const; - template - void set__iname(Arg_&& arg, Args_... args); - std::string* mutable__iname(); - PROTOBUF_NODISCARD std::string* release__iname(); - void set_allocated__iname(std::string* value); - - private: - const std::string& _internal__iname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set__iname( - const std::string& value); - std::string* _internal_mutable__iname(); - - public: - // string _iIName = 8; - void clear__iiname() ; - const std::string& _iiname() const; - template - void set__iiname(Arg_&& arg, Args_... args); - std::string* mutable__iiname(); - PROTOBUF_NODISCARD std::string* release__iiname(); - void set_allocated__iiname(std::string* value); - - private: - const std::string& _internal__iiname() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set__iiname( - const std::string& value); - std::string* _internal_mutable__iiname(); - - 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: - // sint32 _itype = 2; - void clear__itype() ; - ::int32_t _itype() const; - void set__itype(::int32_t value); - - private: - ::int32_t _internal__itype() const; - void _internal_set__itype(::int32_t value); - - public: - // sint32 _ix = 3; - void clear__ix() ; - ::int32_t _ix() const; - void set__ix(::int32_t value); - - private: - ::int32_t _internal__ix() const; - void _internal_set__ix(::int32_t value); - - public: - // sint32 _iy = 4; - void clear__iy() ; - ::int32_t _iy() const; - void set__iy(::int32_t value); - - private: - ::int32_t _internal__iy() const; - void _internal_set__iy(::int32_t value); - - public: - // uint32 _iMagical = 6; - void clear__imagical() ; - ::uint32_t _imagical() const; - void set__imagical(::uint32_t value); - - private: - ::uint32_t _internal__imagical() const; - void _internal_set__imagical(::uint32_t value); - - public: - // uint32 _iClass = 9; - void clear__iclass() ; - ::uint32_t _iclass() const; - void set__iclass(::uint32_t value); - - private: - ::uint32_t _internal__iclass() const; - void _internal_set__iclass(::uint32_t value); - - public: - // sint32 _iCurs = 10; - void clear__icurs() ; - ::int32_t _icurs() const; - void set__icurs(::int32_t value); - - private: - ::int32_t _internal__icurs() const; - void _internal_set__icurs(::int32_t value); - - public: - // sint32 _iValue = 11; - void clear__ivalue() ; - ::int32_t _ivalue() const; - void set__ivalue(::int32_t value); - - private: - ::int32_t _internal__ivalue() const; - void _internal_set__ivalue(::int32_t value); - - public: - // sint32 _iMinDam = 12; - void clear__imindam() ; - ::int32_t _imindam() const; - void set__imindam(::int32_t value); - - private: - ::int32_t _internal__imindam() const; - void _internal_set__imindam(::int32_t value); - - public: - // sint32 _iMaxDam = 13; - void clear__imaxdam() ; - ::int32_t _imaxdam() const; - void set__imaxdam(::int32_t value); - - private: - ::int32_t _internal__imaxdam() const; - void _internal_set__imaxdam(::int32_t value); - - public: - // sint32 _iAC = 14; - void clear__iac() ; - ::int32_t _iac() const; - void set__iac(::int32_t value); - - private: - ::int32_t _internal__iac() const; - void _internal_set__iac(::int32_t value); - - public: - // sint32 _iFlags = 15; - void clear__iflags() ; - ::int32_t _iflags() const; - void set__iflags(::int32_t value); - - private: - ::int32_t _internal__iflags() const; - void _internal_set__iflags(::int32_t value); - - public: - // sint32 _iMiscId = 16; - void clear__imiscid() ; - ::int32_t _imiscid() const; - void set__imiscid(::int32_t value); - - private: - ::int32_t _internal__imiscid() const; - void _internal_set__imiscid(::int32_t value); - - public: - // sint32 _iSpell = 17; - void clear__ispell() ; - ::int32_t _ispell() const; - void set__ispell(::int32_t value); - - private: - ::int32_t _internal__ispell() const; - void _internal_set__ispell(::int32_t value); - - public: - // sint32 _iCharges = 18; - void clear__icharges() ; - ::int32_t _icharges() const; - void set__icharges(::int32_t value); - - private: - ::int32_t _internal__icharges() const; - void _internal_set__icharges(::int32_t value); - - public: - // sint32 _iMaxCharges = 19; - void clear__imaxcharges() ; - ::int32_t _imaxcharges() const; - void set__imaxcharges(::int32_t value); - - private: - ::int32_t _internal__imaxcharges() const; - void _internal_set__imaxcharges(::int32_t value); - - public: - // sint32 _iDurability = 20; - void clear__idurability() ; - ::int32_t _idurability() const; - void set__idurability(::int32_t value); - - private: - ::int32_t _internal__idurability() const; - void _internal_set__idurability(::int32_t value); - - public: - // sint32 _iMaxDur = 21; - void clear__imaxdur() ; - ::int32_t _imaxdur() const; - void set__imaxdur(::int32_t value); - - private: - ::int32_t _internal__imaxdur() const; - void _internal_set__imaxdur(::int32_t value); - - public: - // sint32 _iPLDam = 22; - void clear__ipldam() ; - ::int32_t _ipldam() const; - void set__ipldam(::int32_t value); - - private: - ::int32_t _internal__ipldam() const; - void _internal_set__ipldam(::int32_t value); - - public: - // sint32 _iPLToHit = 23; - void clear__ipltohit() ; - ::int32_t _ipltohit() const; - void set__ipltohit(::int32_t value); - - private: - ::int32_t _internal__ipltohit() const; - void _internal_set__ipltohit(::int32_t value); - - public: - // sint32 _iPLAC = 24; - void clear__iplac() ; - ::int32_t _iplac() const; - void set__iplac(::int32_t value); - - private: - ::int32_t _internal__iplac() const; - void _internal_set__iplac(::int32_t value); - - public: - // sint32 _iPLStr = 25; - void clear__iplstr() ; - ::int32_t _iplstr() const; - void set__iplstr(::int32_t value); - - private: - ::int32_t _internal__iplstr() const; - void _internal_set__iplstr(::int32_t value); - - public: - // sint32 _iPLMag = 26; - void clear__iplmag() ; - ::int32_t _iplmag() const; - void set__iplmag(::int32_t value); - - private: - ::int32_t _internal__iplmag() const; - void _internal_set__iplmag(::int32_t value); - - public: - // bool _iIdentified = 5; - void clear__iidentified() ; - bool _iidentified() const; - void set__iidentified(bool value); - - private: - bool _internal__iidentified() const; - void _internal_set__iidentified(bool value); - - public: - // bool _iStatFlag = 47; - void clear__istatflag() ; - bool _istatflag() const; - void set__istatflag(bool value); - - private: - bool _internal__istatflag() const; - void _internal_set__istatflag(bool value); - - public: - // sint32 _iPLDex = 27; - void clear__ipldex() ; - ::int32_t _ipldex() const; - void set__ipldex(::int32_t value); - - private: - ::int32_t _internal__ipldex() const; - void _internal_set__ipldex(::int32_t value); - - public: - // sint32 _iPLVit = 28; - void clear__iplvit() ; - ::int32_t _iplvit() const; - void set__iplvit(::int32_t value); - - private: - ::int32_t _internal__iplvit() const; - void _internal_set__iplvit(::int32_t value); - - public: - // sint32 _iPLFR = 29; - void clear__iplfr() ; - ::int32_t _iplfr() const; - void set__iplfr(::int32_t value); - - private: - ::int32_t _internal__iplfr() const; - void _internal_set__iplfr(::int32_t value); - - public: - // sint32 _iPLLR = 30; - void clear__ipllr() ; - ::int32_t _ipllr() const; - void set__ipllr(::int32_t value); - - private: - ::int32_t _internal__ipllr() const; - void _internal_set__ipllr(::int32_t value); - - public: - // sint32 _iPLMR = 31; - void clear__iplmr() ; - ::int32_t _iplmr() const; - void set__iplmr(::int32_t value); - - private: - ::int32_t _internal__iplmr() const; - void _internal_set__iplmr(::int32_t value); - - public: - // sint32 _iPLMana = 32; - void clear__iplmana() ; - ::int32_t _iplmana() const; - void set__iplmana(::int32_t value); - - private: - ::int32_t _internal__iplmana() const; - void _internal_set__iplmana(::int32_t value); - - public: - // sint32 _iPLHP = 33; - void clear__iplhp() ; - ::int32_t _iplhp() const; - void set__iplhp(::int32_t value); - - private: - ::int32_t _internal__iplhp() const; - void _internal_set__iplhp(::int32_t value); - - public: - // sint32 _iPLDamMod = 34; - void clear__ipldammod() ; - ::int32_t _ipldammod() const; - void set__ipldammod(::int32_t value); - - private: - ::int32_t _internal__ipldammod() const; - void _internal_set__ipldammod(::int32_t value); - - public: - // sint32 _iPLGetHit = 35; - void clear__iplgethit() ; - ::int32_t _iplgethit() const; - void set__iplgethit(::int32_t value); - - private: - ::int32_t _internal__iplgethit() const; - void _internal_set__iplgethit(::int32_t value); - - public: - // sint32 _iPLLight = 36; - void clear__ipllight() ; - ::int32_t _ipllight() const; - void set__ipllight(::int32_t value); - - private: - ::int32_t _internal__ipllight() const; - void _internal_set__ipllight(::int32_t value); - - public: - // sint32 _iSplLvlAdd = 37; - void clear__ispllvladd() ; - ::int32_t _ispllvladd() const; - void set__ispllvladd(::int32_t value); - - private: - ::int32_t _internal__ispllvladd() const; - void _internal_set__ispllvladd(::int32_t value); - - public: - // sint32 _iFMinDam = 38; - void clear__ifmindam() ; - ::int32_t _ifmindam() const; - void set__ifmindam(::int32_t value); - - private: - ::int32_t _internal__ifmindam() const; - void _internal_set__ifmindam(::int32_t value); - - public: - // sint32 _iFMaxDam = 39; - void clear__ifmaxdam() ; - ::int32_t _ifmaxdam() const; - void set__ifmaxdam(::int32_t value); - - private: - ::int32_t _internal__ifmaxdam() const; - void _internal_set__ifmaxdam(::int32_t value); - - public: - // sint32 _iLMinDam = 40; - void clear__ilmindam() ; - ::int32_t _ilmindam() const; - void set__ilmindam(::int32_t value); - - private: - ::int32_t _internal__ilmindam() const; - void _internal_set__ilmindam(::int32_t value); - - public: - // sint32 _iLMaxDam = 41; - void clear__ilmaxdam() ; - ::int32_t _ilmaxdam() const; - void set__ilmaxdam(::int32_t value); - - private: - ::int32_t _internal__ilmaxdam() const; - void _internal_set__ilmaxdam(::int32_t value); - - public: - // sint32 _iPrePower = 42; - void clear__iprepower() ; - ::int32_t _iprepower() const; - void set__iprepower(::int32_t value); - - private: - ::int32_t _internal__iprepower() const; - void _internal_set__iprepower(::int32_t value); - - public: - // sint32 _iSufPower = 43; - void clear__isufpower() ; - ::int32_t _isufpower() const; - void set__isufpower(::int32_t value); - - private: - ::int32_t _internal__isufpower() const; - void _internal_set__isufpower(::int32_t value); - - public: - // sint32 _iMinStr = 44; - void clear__iminstr() ; - ::int32_t _iminstr() const; - void set__iminstr(::int32_t value); - - private: - ::int32_t _internal__iminstr() const; - void _internal_set__iminstr(::int32_t value); - - public: - // sint32 _iMinMag = 45; - void clear__iminmag() ; - ::int32_t _iminmag() const; - void set__iminmag(::int32_t value); - - private: - ::int32_t _internal__iminmag() const; - void _internal_set__iminmag(::int32_t value); - - public: - // sint32 _iMinDex = 46; - void clear__imindex() ; - ::int32_t _imindex() const; - void set__imindex(::int32_t value); - - private: - ::int32_t _internal__imindex() const; - void _internal_set__imindex(::int32_t value); - - public: - // sint32 IDidx = 48; - void clear_ididx() ; - ::int32_t ididx() const; - void set_ididx(::int32_t value); - - private: - ::int32_t _internal_ididx() const; - void _internal_set_ididx(::int32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.data.ItemData) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 5, 48, 0, - 88, 7> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ItemData& from_msg); - ::google::protobuf::internal::ArenaStringPtr _iname_; - ::google::protobuf::internal::ArenaStringPtr _iiname_; - ::uint32_t id_; - ::int32_t _itype_; - ::int32_t _ix_; - ::int32_t _iy_; - ::uint32_t _imagical_; - ::uint32_t _iclass_; - ::int32_t _icurs_; - ::int32_t _ivalue_; - ::int32_t _imindam_; - ::int32_t _imaxdam_; - ::int32_t _iac_; - ::int32_t _iflags_; - ::int32_t _imiscid_; - ::int32_t _ispell_; - ::int32_t _icharges_; - ::int32_t _imaxcharges_; - ::int32_t _idurability_; - ::int32_t _imaxdur_; - ::int32_t _ipldam_; - ::int32_t _ipltohit_; - ::int32_t _iplac_; - ::int32_t _iplstr_; - ::int32_t _iplmag_; - bool _iidentified_; - bool _istatflag_; - ::int32_t _ipldex_; - ::int32_t _iplvit_; - ::int32_t _iplfr_; - ::int32_t _ipllr_; - ::int32_t _iplmr_; - ::int32_t _iplmana_; - ::int32_t _iplhp_; - ::int32_t _ipldammod_; - ::int32_t _iplgethit_; - ::int32_t _ipllight_; - ::int32_t _ispllvladd_; - ::int32_t _ifmindam_; - ::int32_t _ifmaxdam_; - ::int32_t _ilmindam_; - ::int32_t _ilmaxdam_; - ::int32_t _iprepower_; - ::int32_t _isufpower_; - ::int32_t _iminstr_; - ::int32_t _iminmag_; - ::int32_t _imindex_; - ::int32_t ididx_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_data_2eproto; -}; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// QuestData - -// uint32 id = 1; -inline void QuestData::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t QuestData::id() const { - // @@protoc_insertion_point(field_get:dapi.data.QuestData.id) - return _internal_id(); -} -inline void QuestData::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.data.QuestData.id) -} -inline ::uint32_t QuestData::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void QuestData::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// uint32 state = 2; -inline void QuestData::clear_state() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.state_ = 0u; -} -inline ::uint32_t QuestData::state() const { - // @@protoc_insertion_point(field_get:dapi.data.QuestData.state) - return _internal_state(); -} -inline void QuestData::set_state(::uint32_t value) { - _internal_set_state(value); - // @@protoc_insertion_point(field_set:dapi.data.QuestData.state) -} -inline ::uint32_t QuestData::_internal_state() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.state_; -} -inline void QuestData::_internal_set_state(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.state_ = value; -} - -// ------------------------------------------------------------------- - -// PortalData - -// uint32 x = 1; -inline void PortalData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0u; -} -inline ::uint32_t PortalData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.PortalData.x) - return _internal_x(); -} -inline void PortalData::set_x(::uint32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.PortalData.x) -} -inline ::uint32_t PortalData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void PortalData::_internal_set_x(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// uint32 y = 2; -inline void PortalData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0u; -} -inline ::uint32_t PortalData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.PortalData.y) - return _internal_y(); -} -inline void PortalData::set_y(::uint32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.PortalData.y) -} -inline ::uint32_t PortalData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void PortalData::_internal_set_y(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// uint32 player = 3; -inline void PortalData::clear_player() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_ = 0u; -} -inline ::uint32_t PortalData::player() const { - // @@protoc_insertion_point(field_get:dapi.data.PortalData.player) - return _internal_player(); -} -inline void PortalData::set_player(::uint32_t value) { - _internal_set_player(value); - // @@protoc_insertion_point(field_set:dapi.data.PortalData.player) -} -inline ::uint32_t PortalData::_internal_player() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_; -} -inline void PortalData::_internal_set_player(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_ = value; -} - -// ------------------------------------------------------------------- - -// MissileData - -// sint32 type = 1; -inline void MissileData::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0; -} -inline ::int32_t MissileData::type() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.type) - return _internal_type(); -} -inline void MissileData::set_type(::int32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.type) -} -inline ::int32_t MissileData::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void MissileData::_internal_set_type(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// uint32 x = 2; -inline void MissileData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0u; -} -inline ::uint32_t MissileData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.x) - return _internal_x(); -} -inline void MissileData::set_x(::uint32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.x) -} -inline ::uint32_t MissileData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void MissileData::_internal_set_x(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// uint32 y = 3; -inline void MissileData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0u; -} -inline ::uint32_t MissileData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.y) - return _internal_y(); -} -inline void MissileData::set_y(::uint32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.y) -} -inline ::uint32_t MissileData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void MissileData::_internal_set_y(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// sint32 xvel = 4; -inline void MissileData::clear_xvel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.xvel_ = 0; -} -inline ::int32_t MissileData::xvel() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.xvel) - return _internal_xvel(); -} -inline void MissileData::set_xvel(::int32_t value) { - _internal_set_xvel(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.xvel) -} -inline ::int32_t MissileData::_internal_xvel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.xvel_; -} -inline void MissileData::_internal_set_xvel(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.xvel_ = value; -} - -// sint32 yvel = 5; -inline void MissileData::clear_yvel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.yvel_ = 0; -} -inline ::int32_t MissileData::yvel() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.yvel) - return _internal_yvel(); -} -inline void MissileData::set_yvel(::int32_t value) { - _internal_set_yvel(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.yvel) -} -inline ::int32_t MissileData::_internal_yvel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.yvel_; -} -inline void MissileData::_internal_set_yvel(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.yvel_ = value; -} - -// sint32 sx = 6; -inline void MissileData::clear_sx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sx_ = 0; -} -inline ::int32_t MissileData::sx() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.sx) - return _internal_sx(); -} -inline void MissileData::set_sx(::int32_t value) { - _internal_set_sx(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.sx) -} -inline ::int32_t MissileData::_internal_sx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.sx_; -} -inline void MissileData::_internal_set_sx(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sx_ = value; -} - -// sint32 sy = 7; -inline void MissileData::clear_sy() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sy_ = 0; -} -inline ::int32_t MissileData::sy() const { - // @@protoc_insertion_point(field_get:dapi.data.MissileData.sy) - return _internal_sy(); -} -inline void MissileData::set_sy(::int32_t value) { - _internal_set_sy(value); - // @@protoc_insertion_point(field_set:dapi.data.MissileData.sy) -} -inline ::int32_t MissileData::_internal_sy() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.sy_; -} -inline void MissileData::_internal_set_sy(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.sy_ = value; -} - -// ------------------------------------------------------------------- - -// ObjectData - -// uint32 x = 1; -inline void ObjectData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0u; -} -inline ::uint32_t ObjectData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.x) - return _internal_x(); -} -inline void ObjectData::set_x(::uint32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.x) -} -inline ::uint32_t ObjectData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void ObjectData::_internal_set_x(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// uint32 y = 2; -inline void ObjectData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0u; -} -inline ::uint32_t ObjectData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.y) - return _internal_y(); -} -inline void ObjectData::set_y(::uint32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.y) -} -inline ::uint32_t ObjectData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void ObjectData::_internal_set_y(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// sint32 type = 3; -inline void ObjectData::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0; -} -inline ::int32_t ObjectData::type() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.type) - return _internal_type(); -} -inline void ObjectData::set_type(::int32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.type) -} -inline ::int32_t ObjectData::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void ObjectData::_internal_set_type(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// sint32 shrineType = 4; -inline void ObjectData::clear_shrinetype() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.shrinetype_ = 0; -} -inline ::int32_t ObjectData::shrinetype() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.shrineType) - return _internal_shrinetype(); -} -inline void ObjectData::set_shrinetype(::int32_t value) { - _internal_set_shrinetype(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.shrineType) -} -inline ::int32_t ObjectData::_internal_shrinetype() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.shrinetype_; -} -inline void ObjectData::_internal_set_shrinetype(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.shrinetype_ = value; -} - -// bool solid = 5; -inline void ObjectData::clear_solid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.solid_ = false; -} -inline bool ObjectData::solid() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.solid) - return _internal_solid(); -} -inline void ObjectData::set_solid(bool value) { - _internal_set_solid(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.solid) -} -inline bool ObjectData::_internal_solid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.solid_; -} -inline void ObjectData::_internal_set_solid(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.solid_ = value; -} - -// sint32 doorState = 6; -inline void ObjectData::clear_doorstate() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.doorstate_ = 0; -} -inline ::int32_t ObjectData::doorstate() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.doorState) - return _internal_doorstate(); -} -inline void ObjectData::set_doorstate(::int32_t value) { - _internal_set_doorstate(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.doorState) -} -inline ::int32_t ObjectData::_internal_doorstate() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.doorstate_; -} -inline void ObjectData::_internal_set_doorstate(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.doorstate_ = value; -} - -// bool selectable = 7; -inline void ObjectData::clear_selectable() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.selectable_ = false; -} -inline bool ObjectData::selectable() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.selectable) - return _internal_selectable(); -} -inline void ObjectData::set_selectable(bool value) { - _internal_set_selectable(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.selectable) -} -inline bool ObjectData::_internal_selectable() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.selectable_; -} -inline void ObjectData::_internal_set_selectable(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.selectable_ = value; -} - -// uint32 index = 8; -inline void ObjectData::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t ObjectData::index() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.index) - return _internal_index(); -} -inline void ObjectData::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.index) -} -inline ::uint32_t ObjectData::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void ObjectData::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// bool trapped = 9; -inline void ObjectData::clear_trapped() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.trapped_ = false; -} -inline bool ObjectData::trapped() const { - // @@protoc_insertion_point(field_get:dapi.data.ObjectData.trapped) - return _internal_trapped(); -} -inline void ObjectData::set_trapped(bool value) { - _internal_set_trapped(value); - // @@protoc_insertion_point(field_set:dapi.data.ObjectData.trapped) -} -inline bool ObjectData::_internal_trapped() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.trapped_; -} -inline void ObjectData::_internal_set_trapped(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.trapped_ = value; -} - -// ------------------------------------------------------------------- - -// MonsterData - -// uint32 index = 1; -inline void MonsterData::clear_index() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = 0u; -} -inline ::uint32_t MonsterData::index() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.index) - return _internal_index(); -} -inline void MonsterData::set_index(::uint32_t value) { - _internal_set_index(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.index) -} -inline ::uint32_t MonsterData::_internal_index() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.index_; -} -inline void MonsterData::_internal_set_index(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.index_ = value; -} - -// sint32 x = 2; -inline void MonsterData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0; -} -inline ::int32_t MonsterData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.x) - return _internal_x(); -} -inline void MonsterData::set_x(::int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.x) -} -inline ::int32_t MonsterData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void MonsterData::_internal_set_x(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// sint32 y = 3; -inline void MonsterData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0; -} -inline ::int32_t MonsterData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.y) - return _internal_y(); -} -inline void MonsterData::set_y(::int32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.y) -} -inline ::int32_t MonsterData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void MonsterData::_internal_set_y(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// sint32 futx = 4; -inline void MonsterData::clear_futx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.futx_ = 0; -} -inline ::int32_t MonsterData::futx() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.futx) - return _internal_futx(); -} -inline void MonsterData::set_futx(::int32_t value) { - _internal_set_futx(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.futx) -} -inline ::int32_t MonsterData::_internal_futx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.futx_; -} -inline void MonsterData::_internal_set_futx(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.futx_ = value; -} - -// sint32 futy = 5; -inline void MonsterData::clear_futy() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.futy_ = 0; -} -inline ::int32_t MonsterData::futy() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.futy) - return _internal_futy(); -} -inline void MonsterData::set_futy(::int32_t value) { - _internal_set_futy(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.futy) -} -inline ::int32_t MonsterData::_internal_futy() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.futy_; -} -inline void MonsterData::_internal_set_futy(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.futy_ = value; -} - -// string name = 6; -inline void MonsterData::clear_name() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.name_.ClearToEmpty(); -} -inline const std::string& MonsterData::name() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.name) - return _internal_name(); -} -template -inline PROTOBUF_ALWAYS_INLINE void MonsterData::set_name(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.name_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.name) -} -inline std::string* MonsterData::mutable_name() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_name(); - // @@protoc_insertion_point(field_mutable:dapi.data.MonsterData.name) - return _s; -} -inline const std::string& MonsterData::_internal_name() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.name_.Get(); -} -inline void MonsterData::_internal_set_name(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.name_.Set(value, GetArena()); -} -inline std::string* MonsterData::_internal_mutable_name() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.name_.Mutable( GetArena()); -} -inline std::string* MonsterData::release_name() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.data.MonsterData.name) - return _impl_.name_.Release(); -} -inline void MonsterData::set_allocated_name(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.name_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.name_.IsDefault()) { - _impl_.name_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.data.MonsterData.name) -} - -// sint32 type = 7; -inline void MonsterData::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0; -} -inline ::int32_t MonsterData::type() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.type) - return _internal_type(); -} -inline void MonsterData::set_type(::int32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.type) -} -inline ::int32_t MonsterData::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void MonsterData::_internal_set_type(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// sint32 kills = 8; -inline void MonsterData::clear_kills() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.kills_ = 0; -} -inline ::int32_t MonsterData::kills() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.kills) - return _internal_kills(); -} -inline void MonsterData::set_kills(::int32_t value) { - _internal_set_kills(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.kills) -} -inline ::int32_t MonsterData::_internal_kills() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.kills_; -} -inline void MonsterData::_internal_set_kills(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.kills_ = value; -} - -// sint32 mode = 9; -inline void MonsterData::clear_mode() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.mode_ = 0; -} -inline ::int32_t MonsterData::mode() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.mode) - return _internal_mode(); -} -inline void MonsterData::set_mode(::int32_t value) { - _internal_set_mode(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.mode) -} -inline ::int32_t MonsterData::_internal_mode() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.mode_; -} -inline void MonsterData::_internal_set_mode(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.mode_ = value; -} - -// bool unique = 10; -inline void MonsterData::clear_unique() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.unique_ = false; -} -inline bool MonsterData::unique() const { - // @@protoc_insertion_point(field_get:dapi.data.MonsterData.unique) - return _internal_unique(); -} -inline void MonsterData::set_unique(bool value) { - _internal_set_unique(value); - // @@protoc_insertion_point(field_set:dapi.data.MonsterData.unique) -} -inline bool MonsterData::_internal_unique() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.unique_; -} -inline void MonsterData::_internal_set_unique(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.unique_ = value; -} - -// ------------------------------------------------------------------- - -// TriggerData - -// uint32 lvl = 1; -inline void TriggerData::clear_lvl() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.lvl_ = 0u; -} -inline ::uint32_t TriggerData::lvl() const { - // @@protoc_insertion_point(field_get:dapi.data.TriggerData.lvl) - return _internal_lvl(); -} -inline void TriggerData::set_lvl(::uint32_t value) { - _internal_set_lvl(value); - // @@protoc_insertion_point(field_set:dapi.data.TriggerData.lvl) -} -inline ::uint32_t TriggerData::_internal_lvl() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.lvl_; -} -inline void TriggerData::_internal_set_lvl(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.lvl_ = value; -} - -// sint32 x = 2; -inline void TriggerData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0; -} -inline ::int32_t TriggerData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.TriggerData.x) - return _internal_x(); -} -inline void TriggerData::set_x(::int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.TriggerData.x) -} -inline ::int32_t TriggerData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void TriggerData::_internal_set_x(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// sint32 y = 3; -inline void TriggerData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0; -} -inline ::int32_t TriggerData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.TriggerData.y) - return _internal_y(); -} -inline void TriggerData::set_y(::int32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.TriggerData.y) -} -inline ::int32_t TriggerData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void TriggerData::_internal_set_y(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// sint32 type = 4; -inline void TriggerData::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0; -} -inline ::int32_t TriggerData::type() const { - // @@protoc_insertion_point(field_get:dapi.data.TriggerData.type) - return _internal_type(); -} -inline void TriggerData::set_type(::int32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.data.TriggerData.type) -} -inline ::int32_t TriggerData::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void TriggerData::_internal_set_type(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// ------------------------------------------------------------------- - -// TileData - -// sint32 type = 1; -inline void TileData::clear_type() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = 0; -} -inline ::int32_t TileData::type() const { - // @@protoc_insertion_point(field_get:dapi.data.TileData.type) - return _internal_type(); -} -inline void TileData::set_type(::int32_t value) { - _internal_set_type(value); - // @@protoc_insertion_point(field_set:dapi.data.TileData.type) -} -inline ::int32_t TileData::_internal_type() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.type_; -} -inline void TileData::_internal_set_type(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.type_ = value; -} - -// bool solid = 2; -inline void TileData::clear_solid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.solid_ = false; -} -inline bool TileData::solid() const { - // @@protoc_insertion_point(field_get:dapi.data.TileData.solid) - return _internal_solid(); -} -inline void TileData::set_solid(bool value) { - _internal_set_solid(value); - // @@protoc_insertion_point(field_set:dapi.data.TileData.solid) -} -inline bool TileData::_internal_solid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.solid_; -} -inline void TileData::_internal_set_solid(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.solid_ = value; -} - -// sint32 x = 3; -inline void TileData::clear_x() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = 0; -} -inline ::int32_t TileData::x() const { - // @@protoc_insertion_point(field_get:dapi.data.TileData.x) - return _internal_x(); -} -inline void TileData::set_x(::int32_t value) { - _internal_set_x(value); - // @@protoc_insertion_point(field_set:dapi.data.TileData.x) -} -inline ::int32_t TileData::_internal_x() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.x_; -} -inline void TileData::_internal_set_x(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.x_ = value; -} - -// sint32 y = 4; -inline void TileData::clear_y() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = 0; -} -inline ::int32_t TileData::y() const { - // @@protoc_insertion_point(field_get:dapi.data.TileData.y) - return _internal_y(); -} -inline void TileData::set_y(::int32_t value) { - _internal_set_y(value); - // @@protoc_insertion_point(field_set:dapi.data.TileData.y) -} -inline ::int32_t TileData::_internal_y() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.y_; -} -inline void TileData::_internal_set_y(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.y_ = value; -} - -// bool stopMissile = 5; -inline void TileData::clear_stopmissile() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stopmissile_ = false; -} -inline bool TileData::stopmissile() const { - // @@protoc_insertion_point(field_get:dapi.data.TileData.stopMissile) - return _internal_stopmissile(); -} -inline void TileData::set_stopmissile(bool value) { - _internal_set_stopmissile(value); - // @@protoc_insertion_point(field_set:dapi.data.TileData.stopMissile) -} -inline bool TileData::_internal_stopmissile() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.stopmissile_; -} -inline void TileData::_internal_set_stopmissile(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stopmissile_ = value; -} - -// ------------------------------------------------------------------- - -// TownerData - -// uint32 ID = 1; -inline void TownerData::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t TownerData::id() const { - // @@protoc_insertion_point(field_get:dapi.data.TownerData.ID) - return _internal_id(); -} -inline void TownerData::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.data.TownerData.ID) -} -inline ::uint32_t TownerData::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void TownerData::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// uint32 _ttype = 2; -inline void TownerData::clear__ttype() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ttype_ = 0u; -} -inline ::uint32_t TownerData::_ttype() const { - // @@protoc_insertion_point(field_get:dapi.data.TownerData._ttype) - return _internal__ttype(); -} -inline void TownerData::set__ttype(::uint32_t value) { - _internal_set__ttype(value); - // @@protoc_insertion_point(field_set:dapi.data.TownerData._ttype) -} -inline ::uint32_t TownerData::_internal__ttype() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ttype_; -} -inline void TownerData::_internal_set__ttype(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ttype_ = value; -} - -// sint32 _tx = 3; -inline void TownerData::clear__tx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tx_ = 0; -} -inline ::int32_t TownerData::_tx() const { - // @@protoc_insertion_point(field_get:dapi.data.TownerData._tx) - return _internal__tx(); -} -inline void TownerData::set__tx(::int32_t value) { - _internal_set__tx(value); - // @@protoc_insertion_point(field_set:dapi.data.TownerData._tx) -} -inline ::int32_t TownerData::_internal__tx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._tx_; -} -inline void TownerData::_internal_set__tx(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tx_ = value; -} - -// sint32 _ty = 4; -inline void TownerData::clear__ty() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ty_ = 0; -} -inline ::int32_t TownerData::_ty() const { - // @@protoc_insertion_point(field_get:dapi.data.TownerData._ty) - return _internal__ty(); -} -inline void TownerData::set__ty(::int32_t value) { - _internal_set__ty(value); - // @@protoc_insertion_point(field_set:dapi.data.TownerData._ty) -} -inline ::int32_t TownerData::_internal__ty() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ty_; -} -inline void TownerData::_internal_set__ty(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ty_ = value; -} - -// string _tName = 5; -inline void TownerData::clear__tname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tname_.ClearToEmpty(); -} -inline const std::string& TownerData::_tname() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.data.TownerData._tName) - return _internal__tname(); -} -template -inline PROTOBUF_ALWAYS_INLINE void TownerData::set__tname(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tname_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.data.TownerData._tName) -} -inline std::string* TownerData::mutable__tname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable__tname(); - // @@protoc_insertion_point(field_mutable:dapi.data.TownerData._tName) - return _s; -} -inline const std::string& TownerData::_internal__tname() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._tname_.Get(); -} -inline void TownerData::_internal_set__tname(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tname_.Set(value, GetArena()); -} -inline std::string* TownerData::_internal_mutable__tname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_._tname_.Mutable( GetArena()); -} -inline std::string* TownerData::release__tname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.data.TownerData._tName) - return _impl_._tname_.Release(); -} -inline void TownerData::set_allocated__tname(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._tname_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._tname_.IsDefault()) { - _impl_._tname_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.data.TownerData._tName) -} - -// ------------------------------------------------------------------- - -// ItemData - -// uint32 ID = 1; -inline void ItemData::clear_id() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = 0u; -} -inline ::uint32_t ItemData::id() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData.ID) - return _internal_id(); -} -inline void ItemData::set_id(::uint32_t value) { - _internal_set_id(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData.ID) -} -inline ::uint32_t ItemData::_internal_id() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.id_; -} -inline void ItemData::_internal_set_id(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.id_ = value; -} - -// sint32 _itype = 2; -inline void ItemData::clear__itype() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._itype_ = 0; -} -inline ::int32_t ItemData::_itype() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._itype) - return _internal__itype(); -} -inline void ItemData::set__itype(::int32_t value) { - _internal_set__itype(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._itype) -} -inline ::int32_t ItemData::_internal__itype() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._itype_; -} -inline void ItemData::_internal_set__itype(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._itype_ = value; -} - -// sint32 _ix = 3; -inline void ItemData::clear__ix() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ix_ = 0; -} -inline ::int32_t ItemData::_ix() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._ix) - return _internal__ix(); -} -inline void ItemData::set__ix(::int32_t value) { - _internal_set__ix(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._ix) -} -inline ::int32_t ItemData::_internal__ix() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ix_; -} -inline void ItemData::_internal_set__ix(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ix_ = value; -} - -// sint32 _iy = 4; -inline void ItemData::clear__iy() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iy_ = 0; -} -inline ::int32_t ItemData::_iy() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iy) - return _internal__iy(); -} -inline void ItemData::set__iy(::int32_t value) { - _internal_set__iy(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iy) -} -inline ::int32_t ItemData::_internal__iy() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iy_; -} -inline void ItemData::_internal_set__iy(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iy_ = value; -} - -// bool _iIdentified = 5; -inline void ItemData::clear__iidentified() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iidentified_ = false; -} -inline bool ItemData::_iidentified() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iIdentified) - return _internal__iidentified(); -} -inline void ItemData::set__iidentified(bool value) { - _internal_set__iidentified(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iIdentified) -} -inline bool ItemData::_internal__iidentified() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iidentified_; -} -inline void ItemData::_internal_set__iidentified(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iidentified_ = value; -} - -// uint32 _iMagical = 6; -inline void ItemData::clear__imagical() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imagical_ = 0u; -} -inline ::uint32_t ItemData::_imagical() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMagical) - return _internal__imagical(); -} -inline void ItemData::set__imagical(::uint32_t value) { - _internal_set__imagical(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMagical) -} -inline ::uint32_t ItemData::_internal__imagical() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imagical_; -} -inline void ItemData::_internal_set__imagical(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imagical_ = value; -} - -// string _iName = 7; -inline void ItemData::clear__iname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iname_.ClearToEmpty(); -} -inline const std::string& ItemData::_iname() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iName) - return _internal__iname(); -} -template -inline PROTOBUF_ALWAYS_INLINE void ItemData::set__iname(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iname_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iName) -} -inline std::string* ItemData::mutable__iname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable__iname(); - // @@protoc_insertion_point(field_mutable:dapi.data.ItemData._iName) - return _s; -} -inline const std::string& ItemData::_internal__iname() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iname_.Get(); -} -inline void ItemData::_internal_set__iname(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iname_.Set(value, GetArena()); -} -inline std::string* ItemData::_internal_mutable__iname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_._iname_.Mutable( GetArena()); -} -inline std::string* ItemData::release__iname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.data.ItemData._iName) - return _impl_._iname_.Release(); -} -inline void ItemData::set_allocated__iname(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iname_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._iname_.IsDefault()) { - _impl_._iname_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.data.ItemData._iName) -} - -// string _iIName = 8; -inline void ItemData::clear__iiname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iiname_.ClearToEmpty(); -} -inline const std::string& ItemData::_iiname() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iIName) - return _internal__iiname(); -} -template -inline PROTOBUF_ALWAYS_INLINE void ItemData::set__iiname(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iiname_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iIName) -} -inline std::string* ItemData::mutable__iiname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable__iiname(); - // @@protoc_insertion_point(field_mutable:dapi.data.ItemData._iIName) - return _s; -} -inline const std::string& ItemData::_internal__iiname() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iiname_.Get(); -} -inline void ItemData::_internal_set__iiname(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iiname_.Set(value, GetArena()); -} -inline std::string* ItemData::_internal_mutable__iiname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_._iiname_.Mutable( GetArena()); -} -inline std::string* ItemData::release__iiname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.data.ItemData._iIName) - return _impl_._iiname_.Release(); -} -inline void ItemData::set_allocated__iiname(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iiname_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._iiname_.IsDefault()) { - _impl_._iiname_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.data.ItemData._iIName) -} - -// uint32 _iClass = 9; -inline void ItemData::clear__iclass() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iclass_ = 0u; -} -inline ::uint32_t ItemData::_iclass() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iClass) - return _internal__iclass(); -} -inline void ItemData::set__iclass(::uint32_t value) { - _internal_set__iclass(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iClass) -} -inline ::uint32_t ItemData::_internal__iclass() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iclass_; -} -inline void ItemData::_internal_set__iclass(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iclass_ = value; -} - -// sint32 _iCurs = 10; -inline void ItemData::clear__icurs() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._icurs_ = 0; -} -inline ::int32_t ItemData::_icurs() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iCurs) - return _internal__icurs(); -} -inline void ItemData::set__icurs(::int32_t value) { - _internal_set__icurs(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iCurs) -} -inline ::int32_t ItemData::_internal__icurs() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._icurs_; -} -inline void ItemData::_internal_set__icurs(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._icurs_ = value; -} - -// sint32 _iValue = 11; -inline void ItemData::clear__ivalue() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ivalue_ = 0; -} -inline ::int32_t ItemData::_ivalue() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iValue) - return _internal__ivalue(); -} -inline void ItemData::set__ivalue(::int32_t value) { - _internal_set__ivalue(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iValue) -} -inline ::int32_t ItemData::_internal__ivalue() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ivalue_; -} -inline void ItemData::_internal_set__ivalue(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ivalue_ = value; -} - -// sint32 _iMinDam = 12; -inline void ItemData::clear__imindam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imindam_ = 0; -} -inline ::int32_t ItemData::_imindam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinDam) - return _internal__imindam(); -} -inline void ItemData::set__imindam(::int32_t value) { - _internal_set__imindam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinDam) -} -inline ::int32_t ItemData::_internal__imindam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imindam_; -} -inline void ItemData::_internal_set__imindam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imindam_ = value; -} - -// sint32 _iMaxDam = 13; -inline void ItemData::clear__imaxdam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxdam_ = 0; -} -inline ::int32_t ItemData::_imaxdam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxDam) - return _internal__imaxdam(); -} -inline void ItemData::set__imaxdam(::int32_t value) { - _internal_set__imaxdam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxDam) -} -inline ::int32_t ItemData::_internal__imaxdam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imaxdam_; -} -inline void ItemData::_internal_set__imaxdam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxdam_ = value; -} - -// sint32 _iAC = 14; -inline void ItemData::clear__iac() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iac_ = 0; -} -inline ::int32_t ItemData::_iac() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iAC) - return _internal__iac(); -} -inline void ItemData::set__iac(::int32_t value) { - _internal_set__iac(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iAC) -} -inline ::int32_t ItemData::_internal__iac() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iac_; -} -inline void ItemData::_internal_set__iac(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iac_ = value; -} - -// sint32 _iFlags = 15; -inline void ItemData::clear__iflags() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iflags_ = 0; -} -inline ::int32_t ItemData::_iflags() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFlags) - return _internal__iflags(); -} -inline void ItemData::set__iflags(::int32_t value) { - _internal_set__iflags(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFlags) -} -inline ::int32_t ItemData::_internal__iflags() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iflags_; -} -inline void ItemData::_internal_set__iflags(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iflags_ = value; -} - -// sint32 _iMiscId = 16; -inline void ItemData::clear__imiscid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imiscid_ = 0; -} -inline ::int32_t ItemData::_imiscid() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMiscId) - return _internal__imiscid(); -} -inline void ItemData::set__imiscid(::int32_t value) { - _internal_set__imiscid(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMiscId) -} -inline ::int32_t ItemData::_internal__imiscid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imiscid_; -} -inline void ItemData::_internal_set__imiscid(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imiscid_ = value; -} - -// sint32 _iSpell = 17; -inline void ItemData::clear__ispell() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ispell_ = 0; -} -inline ::int32_t ItemData::_ispell() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSpell) - return _internal__ispell(); -} -inline void ItemData::set__ispell(::int32_t value) { - _internal_set__ispell(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSpell) -} -inline ::int32_t ItemData::_internal__ispell() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ispell_; -} -inline void ItemData::_internal_set__ispell(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ispell_ = value; -} - -// sint32 _iCharges = 18; -inline void ItemData::clear__icharges() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._icharges_ = 0; -} -inline ::int32_t ItemData::_icharges() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iCharges) - return _internal__icharges(); -} -inline void ItemData::set__icharges(::int32_t value) { - _internal_set__icharges(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iCharges) -} -inline ::int32_t ItemData::_internal__icharges() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._icharges_; -} -inline void ItemData::_internal_set__icharges(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._icharges_ = value; -} - -// sint32 _iMaxCharges = 19; -inline void ItemData::clear__imaxcharges() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxcharges_ = 0; -} -inline ::int32_t ItemData::_imaxcharges() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxCharges) - return _internal__imaxcharges(); -} -inline void ItemData::set__imaxcharges(::int32_t value) { - _internal_set__imaxcharges(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxCharges) -} -inline ::int32_t ItemData::_internal__imaxcharges() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imaxcharges_; -} -inline void ItemData::_internal_set__imaxcharges(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxcharges_ = value; -} - -// sint32 _iDurability = 20; -inline void ItemData::clear__idurability() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._idurability_ = 0; -} -inline ::int32_t ItemData::_idurability() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iDurability) - return _internal__idurability(); -} -inline void ItemData::set__idurability(::int32_t value) { - _internal_set__idurability(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iDurability) -} -inline ::int32_t ItemData::_internal__idurability() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._idurability_; -} -inline void ItemData::_internal_set__idurability(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._idurability_ = value; -} - -// sint32 _iMaxDur = 21; -inline void ItemData::clear__imaxdur() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxdur_ = 0; -} -inline ::int32_t ItemData::_imaxdur() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMaxDur) - return _internal__imaxdur(); -} -inline void ItemData::set__imaxdur(::int32_t value) { - _internal_set__imaxdur(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMaxDur) -} -inline ::int32_t ItemData::_internal__imaxdur() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imaxdur_; -} -inline void ItemData::_internal_set__imaxdur(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imaxdur_ = value; -} - -// sint32 _iPLDam = 22; -inline void ItemData::clear__ipldam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldam_ = 0; -} -inline ::int32_t ItemData::_ipldam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDam) - return _internal__ipldam(); -} -inline void ItemData::set__ipldam(::int32_t value) { - _internal_set__ipldam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDam) -} -inline ::int32_t ItemData::_internal__ipldam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipldam_; -} -inline void ItemData::_internal_set__ipldam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldam_ = value; -} - -// sint32 _iPLToHit = 23; -inline void ItemData::clear__ipltohit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipltohit_ = 0; -} -inline ::int32_t ItemData::_ipltohit() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLToHit) - return _internal__ipltohit(); -} -inline void ItemData::set__ipltohit(::int32_t value) { - _internal_set__ipltohit(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLToHit) -} -inline ::int32_t ItemData::_internal__ipltohit() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipltohit_; -} -inline void ItemData::_internal_set__ipltohit(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipltohit_ = value; -} - -// sint32 _iPLAC = 24; -inline void ItemData::clear__iplac() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplac_ = 0; -} -inline ::int32_t ItemData::_iplac() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLAC) - return _internal__iplac(); -} -inline void ItemData::set__iplac(::int32_t value) { - _internal_set__iplac(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLAC) -} -inline ::int32_t ItemData::_internal__iplac() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplac_; -} -inline void ItemData::_internal_set__iplac(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplac_ = value; -} - -// sint32 _iPLStr = 25; -inline void ItemData::clear__iplstr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplstr_ = 0; -} -inline ::int32_t ItemData::_iplstr() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLStr) - return _internal__iplstr(); -} -inline void ItemData::set__iplstr(::int32_t value) { - _internal_set__iplstr(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLStr) -} -inline ::int32_t ItemData::_internal__iplstr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplstr_; -} -inline void ItemData::_internal_set__iplstr(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplstr_ = value; -} - -// sint32 _iPLMag = 26; -inline void ItemData::clear__iplmag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmag_ = 0; -} -inline ::int32_t ItemData::_iplmag() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMag) - return _internal__iplmag(); -} -inline void ItemData::set__iplmag(::int32_t value) { - _internal_set__iplmag(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMag) -} -inline ::int32_t ItemData::_internal__iplmag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplmag_; -} -inline void ItemData::_internal_set__iplmag(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmag_ = value; -} - -// sint32 _iPLDex = 27; -inline void ItemData::clear__ipldex() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldex_ = 0; -} -inline ::int32_t ItemData::_ipldex() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDex) - return _internal__ipldex(); -} -inline void ItemData::set__ipldex(::int32_t value) { - _internal_set__ipldex(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDex) -} -inline ::int32_t ItemData::_internal__ipldex() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipldex_; -} -inline void ItemData::_internal_set__ipldex(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldex_ = value; -} - -// sint32 _iPLVit = 28; -inline void ItemData::clear__iplvit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplvit_ = 0; -} -inline ::int32_t ItemData::_iplvit() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLVit) - return _internal__iplvit(); -} -inline void ItemData::set__iplvit(::int32_t value) { - _internal_set__iplvit(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLVit) -} -inline ::int32_t ItemData::_internal__iplvit() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplvit_; -} -inline void ItemData::_internal_set__iplvit(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplvit_ = value; -} - -// sint32 _iPLFR = 29; -inline void ItemData::clear__iplfr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplfr_ = 0; -} -inline ::int32_t ItemData::_iplfr() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLFR) - return _internal__iplfr(); -} -inline void ItemData::set__iplfr(::int32_t value) { - _internal_set__iplfr(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLFR) -} -inline ::int32_t ItemData::_internal__iplfr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplfr_; -} -inline void ItemData::_internal_set__iplfr(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplfr_ = value; -} - -// sint32 _iPLLR = 30; -inline void ItemData::clear__ipllr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipllr_ = 0; -} -inline ::int32_t ItemData::_ipllr() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLLR) - return _internal__ipllr(); -} -inline void ItemData::set__ipllr(::int32_t value) { - _internal_set__ipllr(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLLR) -} -inline ::int32_t ItemData::_internal__ipllr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipllr_; -} -inline void ItemData::_internal_set__ipllr(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipllr_ = value; -} - -// sint32 _iPLMR = 31; -inline void ItemData::clear__iplmr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmr_ = 0; -} -inline ::int32_t ItemData::_iplmr() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMR) - return _internal__iplmr(); -} -inline void ItemData::set__iplmr(::int32_t value) { - _internal_set__iplmr(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMR) -} -inline ::int32_t ItemData::_internal__iplmr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplmr_; -} -inline void ItemData::_internal_set__iplmr(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmr_ = value; -} - -// sint32 _iPLMana = 32; -inline void ItemData::clear__iplmana() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmana_ = 0; -} -inline ::int32_t ItemData::_iplmana() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLMana) - return _internal__iplmana(); -} -inline void ItemData::set__iplmana(::int32_t value) { - _internal_set__iplmana(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLMana) -} -inline ::int32_t ItemData::_internal__iplmana() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplmana_; -} -inline void ItemData::_internal_set__iplmana(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplmana_ = value; -} - -// sint32 _iPLHP = 33; -inline void ItemData::clear__iplhp() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplhp_ = 0; -} -inline ::int32_t ItemData::_iplhp() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLHP) - return _internal__iplhp(); -} -inline void ItemData::set__iplhp(::int32_t value) { - _internal_set__iplhp(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLHP) -} -inline ::int32_t ItemData::_internal__iplhp() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplhp_; -} -inline void ItemData::_internal_set__iplhp(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplhp_ = value; -} - -// sint32 _iPLDamMod = 34; -inline void ItemData::clear__ipldammod() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldammod_ = 0; -} -inline ::int32_t ItemData::_ipldammod() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLDamMod) - return _internal__ipldammod(); -} -inline void ItemData::set__ipldammod(::int32_t value) { - _internal_set__ipldammod(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLDamMod) -} -inline ::int32_t ItemData::_internal__ipldammod() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipldammod_; -} -inline void ItemData::_internal_set__ipldammod(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipldammod_ = value; -} - -// sint32 _iPLGetHit = 35; -inline void ItemData::clear__iplgethit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplgethit_ = 0; -} -inline ::int32_t ItemData::_iplgethit() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLGetHit) - return _internal__iplgethit(); -} -inline void ItemData::set__iplgethit(::int32_t value) { - _internal_set__iplgethit(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLGetHit) -} -inline ::int32_t ItemData::_internal__iplgethit() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iplgethit_; -} -inline void ItemData::_internal_set__iplgethit(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iplgethit_ = value; -} - -// sint32 _iPLLight = 36; -inline void ItemData::clear__ipllight() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipllight_ = 0; -} -inline ::int32_t ItemData::_ipllight() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPLLight) - return _internal__ipllight(); -} -inline void ItemData::set__ipllight(::int32_t value) { - _internal_set__ipllight(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPLLight) -} -inline ::int32_t ItemData::_internal__ipllight() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ipllight_; -} -inline void ItemData::_internal_set__ipllight(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ipllight_ = value; -} - -// sint32 _iSplLvlAdd = 37; -inline void ItemData::clear__ispllvladd() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ispllvladd_ = 0; -} -inline ::int32_t ItemData::_ispllvladd() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSplLvlAdd) - return _internal__ispllvladd(); -} -inline void ItemData::set__ispllvladd(::int32_t value) { - _internal_set__ispllvladd(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSplLvlAdd) -} -inline ::int32_t ItemData::_internal__ispllvladd() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ispllvladd_; -} -inline void ItemData::_internal_set__ispllvladd(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ispllvladd_ = value; -} - -// sint32 _iFMinDam = 38; -inline void ItemData::clear__ifmindam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ifmindam_ = 0; -} -inline ::int32_t ItemData::_ifmindam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFMinDam) - return _internal__ifmindam(); -} -inline void ItemData::set__ifmindam(::int32_t value) { - _internal_set__ifmindam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFMinDam) -} -inline ::int32_t ItemData::_internal__ifmindam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ifmindam_; -} -inline void ItemData::_internal_set__ifmindam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ifmindam_ = value; -} - -// sint32 _iFMaxDam = 39; -inline void ItemData::clear__ifmaxdam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ifmaxdam_ = 0; -} -inline ::int32_t ItemData::_ifmaxdam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iFMaxDam) - return _internal__ifmaxdam(); -} -inline void ItemData::set__ifmaxdam(::int32_t value) { - _internal_set__ifmaxdam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iFMaxDam) -} -inline ::int32_t ItemData::_internal__ifmaxdam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ifmaxdam_; -} -inline void ItemData::_internal_set__ifmaxdam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ifmaxdam_ = value; -} - -// sint32 _iLMinDam = 40; -inline void ItemData::clear__ilmindam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ilmindam_ = 0; -} -inline ::int32_t ItemData::_ilmindam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iLMinDam) - return _internal__ilmindam(); -} -inline void ItemData::set__ilmindam(::int32_t value) { - _internal_set__ilmindam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iLMinDam) -} -inline ::int32_t ItemData::_internal__ilmindam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ilmindam_; -} -inline void ItemData::_internal_set__ilmindam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ilmindam_ = value; -} - -// sint32 _iLMaxDam = 41; -inline void ItemData::clear__ilmaxdam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ilmaxdam_ = 0; -} -inline ::int32_t ItemData::_ilmaxdam() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iLMaxDam) - return _internal__ilmaxdam(); -} -inline void ItemData::set__ilmaxdam(::int32_t value) { - _internal_set__ilmaxdam(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iLMaxDam) -} -inline ::int32_t ItemData::_internal__ilmaxdam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._ilmaxdam_; -} -inline void ItemData::_internal_set__ilmaxdam(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._ilmaxdam_ = value; -} - -// sint32 _iPrePower = 42; -inline void ItemData::clear__iprepower() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iprepower_ = 0; -} -inline ::int32_t ItemData::_iprepower() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iPrePower) - return _internal__iprepower(); -} -inline void ItemData::set__iprepower(::int32_t value) { - _internal_set__iprepower(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iPrePower) -} -inline ::int32_t ItemData::_internal__iprepower() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iprepower_; -} -inline void ItemData::_internal_set__iprepower(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iprepower_ = value; -} - -// sint32 _iSufPower = 43; -inline void ItemData::clear__isufpower() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._isufpower_ = 0; -} -inline ::int32_t ItemData::_isufpower() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iSufPower) - return _internal__isufpower(); -} -inline void ItemData::set__isufpower(::int32_t value) { - _internal_set__isufpower(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iSufPower) -} -inline ::int32_t ItemData::_internal__isufpower() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._isufpower_; -} -inline void ItemData::_internal_set__isufpower(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._isufpower_ = value; -} - -// sint32 _iMinStr = 44; -inline void ItemData::clear__iminstr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iminstr_ = 0; -} -inline ::int32_t ItemData::_iminstr() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinStr) - return _internal__iminstr(); -} -inline void ItemData::set__iminstr(::int32_t value) { - _internal_set__iminstr(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinStr) -} -inline ::int32_t ItemData::_internal__iminstr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iminstr_; -} -inline void ItemData::_internal_set__iminstr(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iminstr_ = value; -} - -// sint32 _iMinMag = 45; -inline void ItemData::clear__iminmag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iminmag_ = 0; -} -inline ::int32_t ItemData::_iminmag() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinMag) - return _internal__iminmag(); -} -inline void ItemData::set__iminmag(::int32_t value) { - _internal_set__iminmag(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinMag) -} -inline ::int32_t ItemData::_internal__iminmag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._iminmag_; -} -inline void ItemData::_internal_set__iminmag(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._iminmag_ = value; -} - -// sint32 _iMinDex = 46; -inline void ItemData::clear__imindex() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imindex_ = 0; -} -inline ::int32_t ItemData::_imindex() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iMinDex) - return _internal__imindex(); -} -inline void ItemData::set__imindex(::int32_t value) { - _internal_set__imindex(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iMinDex) -} -inline ::int32_t ItemData::_internal__imindex() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._imindex_; -} -inline void ItemData::_internal_set__imindex(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._imindex_ = value; -} - -// bool _iStatFlag = 47; -inline void ItemData::clear__istatflag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._istatflag_ = false; -} -inline bool ItemData::_istatflag() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData._iStatFlag) - return _internal__istatflag(); -} -inline void ItemData::set__istatflag(bool value) { - _internal_set__istatflag(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData._iStatFlag) -} -inline bool ItemData::_internal__istatflag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._istatflag_; -} -inline void ItemData::_internal_set__istatflag(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._istatflag_ = value; -} - -// sint32 IDidx = 48; -inline void ItemData::clear_ididx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ididx_ = 0; -} -inline ::int32_t ItemData::ididx() const { - // @@protoc_insertion_point(field_get:dapi.data.ItemData.IDidx) - return _internal_ididx(); -} -inline void ItemData::set_ididx(::int32_t value) { - _internal_set_ididx(value); - // @@protoc_insertion_point(field_set:dapi.data.ItemData.IDidx) -} -inline ::int32_t ItemData::_internal_ididx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.ididx_; -} -inline void ItemData::_internal_set_ididx(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.ididx_ = value; -} - -// ------------------------------------------------------------------- - -// PlayerData - -// sint32 _pmode = 1; -inline void PlayerData::clear__pmode() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmode_ = 0; -} -inline ::int32_t PlayerData::_pmode() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pmode) - return _internal__pmode(); -} -inline void PlayerData::set__pmode(::int32_t value) { - _internal_set__pmode(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pmode) -} -inline ::int32_t PlayerData::_internal__pmode() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmode_; -} -inline void PlayerData::_internal_set__pmode(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmode_ = value; -} - -// sint32 pnum = 2; -inline void PlayerData::clear_pnum() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pnum_ = 0; -} -inline ::int32_t PlayerData::pnum() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.pnum) - return _internal_pnum(); -} -inline void PlayerData::set_pnum(::int32_t value) { - _internal_set_pnum(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.pnum) -} -inline ::int32_t PlayerData::_internal_pnum() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pnum_; -} -inline void PlayerData::_internal_set_pnum(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pnum_ = value; -} - -// sint32 plrlevel = 3; -inline void PlayerData::clear_plrlevel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.plrlevel_ = 0; -} -inline ::int32_t PlayerData::plrlevel() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.plrlevel) - return _internal_plrlevel(); -} -inline void PlayerData::set_plrlevel(::int32_t value) { - _internal_set_plrlevel(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.plrlevel) -} -inline ::int32_t PlayerData::_internal_plrlevel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.plrlevel_; -} -inline void PlayerData::_internal_set_plrlevel(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.plrlevel_ = value; -} - -// sint32 _px = 4; -inline void PlayerData::clear__px() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._px_ = 0; -} -inline ::int32_t PlayerData::_px() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._px) - return _internal__px(); -} -inline void PlayerData::set__px(::int32_t value) { - _internal_set__px(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._px) -} -inline ::int32_t PlayerData::_internal__px() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._px_; -} -inline void PlayerData::_internal_set__px(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._px_ = value; -} - -// sint32 _py = 5; -inline void PlayerData::clear__py() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._py_ = 0; -} -inline ::int32_t PlayerData::_py() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._py) - return _internal__py(); -} -inline void PlayerData::set__py(::int32_t value) { - _internal_set__py(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._py) -} -inline ::int32_t PlayerData::_internal__py() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._py_; -} -inline void PlayerData::_internal_set__py(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._py_ = value; -} - -// sint32 _pfutx = 6; -inline void PlayerData::clear__pfutx() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfutx_ = 0; -} -inline ::int32_t PlayerData::_pfutx() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pfutx) - return _internal__pfutx(); -} -inline void PlayerData::set__pfutx(::int32_t value) { - _internal_set__pfutx(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pfutx) -} -inline ::int32_t PlayerData::_internal__pfutx() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pfutx_; -} -inline void PlayerData::_internal_set__pfutx(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfutx_ = value; -} - -// sint32 _pfuty = 7; -inline void PlayerData::clear__pfuty() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfuty_ = 0; -} -inline ::int32_t PlayerData::_pfuty() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pfuty) - return _internal__pfuty(); -} -inline void PlayerData::set__pfuty(::int32_t value) { - _internal_set__pfuty(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pfuty) -} -inline ::int32_t PlayerData::_internal__pfuty() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pfuty_; -} -inline void PlayerData::_internal_set__pfuty(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfuty_ = value; -} - -// sint32 _pdir = 8; -inline void PlayerData::clear__pdir() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdir_ = 0; -} -inline ::int32_t PlayerData::_pdir() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pdir) - return _internal__pdir(); -} -inline void PlayerData::set__pdir(::int32_t value) { - _internal_set__pdir(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pdir) -} -inline ::int32_t PlayerData::_internal__pdir() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pdir_; -} -inline void PlayerData::_internal_set__pdir(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdir_ = value; -} - -// sint32 _pRSpell = 9; -inline void PlayerData::clear__prspell() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._prspell_ = 0; -} -inline ::int32_t PlayerData::_prspell() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pRSpell) - return _internal__prspell(); -} -inline void PlayerData::set__prspell(::int32_t value) { - _internal_set__prspell(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pRSpell) -} -inline ::int32_t PlayerData::_internal__prspell() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._prspell_; -} -inline void PlayerData::_internal_set__prspell(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._prspell_ = value; -} - -// uint32 _pRsplType = 10; -inline void PlayerData::clear__prspltype() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._prspltype_ = 0u; -} -inline ::uint32_t PlayerData::_prspltype() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pRsplType) - return _internal__prspltype(); -} -inline void PlayerData::set__prspltype(::uint32_t value) { - _internal_set__prspltype(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pRsplType) -} -inline ::uint32_t PlayerData::_internal__prspltype() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._prspltype_; -} -inline void PlayerData::_internal_set__prspltype(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._prspltype_ = value; -} - -// repeated uint32 _pSplLvl = 11; -inline int PlayerData::_internal__pspllvl_size() const { - return _internal__pspllvl().size(); -} -inline int PlayerData::_pspllvl_size() const { - return _internal__pspllvl_size(); -} -inline void PlayerData::clear__pspllvl() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pspllvl_.Clear(); -} -inline ::uint32_t PlayerData::_pspllvl(int index) const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pSplLvl) - return _internal__pspllvl().Get(index); -} -inline void PlayerData::set__pspllvl(int index, ::uint32_t value) { - _internal_mutable__pspllvl()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pSplLvl) -} -inline void PlayerData::add__pspllvl(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable__pspllvl()->Add(value); - // @@protoc_insertion_point(field_add:dapi.data.PlayerData._pSplLvl) -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& PlayerData::_pspllvl() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.data.PlayerData._pSplLvl) - return _internal__pspllvl(); -} -inline ::google::protobuf::RepeatedField<::uint32_t>* PlayerData::mutable__pspllvl() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData._pSplLvl) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable__pspllvl(); -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& -PlayerData::_internal__pspllvl() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pspllvl_; -} -inline ::google::protobuf::RepeatedField<::uint32_t>* PlayerData::_internal_mutable__pspllvl() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_._pspllvl_; -} - -// uint64 _pMemSpells = 12; -inline void PlayerData::clear__pmemspells() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmemspells_ = ::uint64_t{0u}; -} -inline ::uint64_t PlayerData::_pmemspells() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMemSpells) - return _internal__pmemspells(); -} -inline void PlayerData::set__pmemspells(::uint64_t value) { - _internal_set__pmemspells(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMemSpells) -} -inline ::uint64_t PlayerData::_internal__pmemspells() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmemspells_; -} -inline void PlayerData::_internal_set__pmemspells(::uint64_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmemspells_ = value; -} - -// uint64 _pAblSpells = 13; -inline void PlayerData::clear__pablspells() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pablspells_ = ::uint64_t{0u}; -} -inline ::uint64_t PlayerData::_pablspells() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pAblSpells) - return _internal__pablspells(); -} -inline void PlayerData::set__pablspells(::uint64_t value) { - _internal_set__pablspells(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pAblSpells) -} -inline ::uint64_t PlayerData::_internal__pablspells() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pablspells_; -} -inline void PlayerData::_internal_set__pablspells(::uint64_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pablspells_ = value; -} - -// uint64 _pScrlSpells = 14; -inline void PlayerData::clear__pscrlspells() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pscrlspells_ = ::uint64_t{0u}; -} -inline ::uint64_t PlayerData::_pscrlspells() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pScrlSpells) - return _internal__pscrlspells(); -} -inline void PlayerData::set__pscrlspells(::uint64_t value) { - _internal_set__pscrlspells(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pScrlSpells) -} -inline ::uint64_t PlayerData::_internal__pscrlspells() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pscrlspells_; -} -inline void PlayerData::_internal_set__pscrlspells(::uint64_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pscrlspells_ = value; -} - -// string _pName = 15; -inline void PlayerData::clear__pname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pname_.ClearToEmpty(); -} -inline const std::string& PlayerData::_pname() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pName) - return _internal__pname(); -} -template -inline PROTOBUF_ALWAYS_INLINE void PlayerData::set__pname(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pname_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pName) -} -inline std::string* PlayerData::mutable__pname() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable__pname(); - // @@protoc_insertion_point(field_mutable:dapi.data.PlayerData._pName) - return _s; -} -inline const std::string& PlayerData::_internal__pname() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pname_.Get(); -} -inline void PlayerData::_internal_set__pname(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pname_.Set(value, GetArena()); -} -inline std::string* PlayerData::_internal_mutable__pname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_._pname_.Mutable( GetArena()); -} -inline std::string* PlayerData::release__pname() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.data.PlayerData._pName) - return _impl_._pname_.Release(); -} -inline void PlayerData::set_allocated__pname(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pname_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_._pname_.IsDefault()) { - _impl_._pname_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.data.PlayerData._pName) -} - -// uint32 _pClass = 16; -inline void PlayerData::clear__pclass() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pclass_ = 0u; -} -inline ::uint32_t PlayerData::_pclass() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pClass) - return _internal__pclass(); -} -inline void PlayerData::set__pclass(::uint32_t value) { - _internal_set__pclass(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pClass) -} -inline ::uint32_t PlayerData::_internal__pclass() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pclass_; -} -inline void PlayerData::_internal_set__pclass(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pclass_ = value; -} - -// uint32 _pStrength = 17; -inline void PlayerData::clear__pstrength() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pstrength_ = 0u; -} -inline ::uint32_t PlayerData::_pstrength() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pStrength) - return _internal__pstrength(); -} -inline void PlayerData::set__pstrength(::uint32_t value) { - _internal_set__pstrength(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pStrength) -} -inline ::uint32_t PlayerData::_internal__pstrength() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pstrength_; -} -inline void PlayerData::_internal_set__pstrength(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pstrength_ = value; -} - -// uint32 _pBaseStr = 18; -inline void PlayerData::clear__pbasestr() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasestr_ = 0u; -} -inline ::uint32_t PlayerData::_pbasestr() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseStr) - return _internal__pbasestr(); -} -inline void PlayerData::set__pbasestr(::uint32_t value) { - _internal_set__pbasestr(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseStr) -} -inline ::uint32_t PlayerData::_internal__pbasestr() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pbasestr_; -} -inline void PlayerData::_internal_set__pbasestr(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasestr_ = value; -} - -// uint32 _pMagic = 19; -inline void PlayerData::clear__pmagic() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmagic_ = 0u; -} -inline ::uint32_t PlayerData::_pmagic() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMagic) - return _internal__pmagic(); -} -inline void PlayerData::set__pmagic(::uint32_t value) { - _internal_set__pmagic(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMagic) -} -inline ::uint32_t PlayerData::_internal__pmagic() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmagic_; -} -inline void PlayerData::_internal_set__pmagic(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmagic_ = value; -} - -// uint32 _pBaseMag = 20; -inline void PlayerData::clear__pbasemag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasemag_ = 0u; -} -inline ::uint32_t PlayerData::_pbasemag() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseMag) - return _internal__pbasemag(); -} -inline void PlayerData::set__pbasemag(::uint32_t value) { - _internal_set__pbasemag(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseMag) -} -inline ::uint32_t PlayerData::_internal__pbasemag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pbasemag_; -} -inline void PlayerData::_internal_set__pbasemag(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasemag_ = value; -} - -// uint32 _pDexterity = 21; -inline void PlayerData::clear__pdexterity() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdexterity_ = 0u; -} -inline ::uint32_t PlayerData::_pdexterity() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pDexterity) - return _internal__pdexterity(); -} -inline void PlayerData::set__pdexterity(::uint32_t value) { - _internal_set__pdexterity(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pDexterity) -} -inline ::uint32_t PlayerData::_internal__pdexterity() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pdexterity_; -} -inline void PlayerData::_internal_set__pdexterity(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdexterity_ = value; -} - -// uint32 _pBaseDex = 22; -inline void PlayerData::clear__pbasedex() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasedex_ = 0u; -} -inline ::uint32_t PlayerData::_pbasedex() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseDex) - return _internal__pbasedex(); -} -inline void PlayerData::set__pbasedex(::uint32_t value) { - _internal_set__pbasedex(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseDex) -} -inline ::uint32_t PlayerData::_internal__pbasedex() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pbasedex_; -} -inline void PlayerData::_internal_set__pbasedex(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasedex_ = value; -} - -// uint32 _pVitality = 23; -inline void PlayerData::clear__pvitality() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pvitality_ = 0u; -} -inline ::uint32_t PlayerData::_pvitality() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pVitality) - return _internal__pvitality(); -} -inline void PlayerData::set__pvitality(::uint32_t value) { - _internal_set__pvitality(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pVitality) -} -inline ::uint32_t PlayerData::_internal__pvitality() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pvitality_; -} -inline void PlayerData::_internal_set__pvitality(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pvitality_ = value; -} - -// uint32 _pBaseVit = 24; -inline void PlayerData::clear__pbasevit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasevit_ = 0u; -} -inline ::uint32_t PlayerData::_pbasevit() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pBaseVit) - return _internal__pbasevit(); -} -inline void PlayerData::set__pbasevit(::uint32_t value) { - _internal_set__pbasevit(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pBaseVit) -} -inline ::uint32_t PlayerData::_internal__pbasevit() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pbasevit_; -} -inline void PlayerData::_internal_set__pbasevit(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pbasevit_ = value; -} - -// uint32 _pStatPts = 25; -inline void PlayerData::clear__pstatpts() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pstatpts_ = 0u; -} -inline ::uint32_t PlayerData::_pstatpts() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pStatPts) - return _internal__pstatpts(); -} -inline void PlayerData::set__pstatpts(::uint32_t value) { - _internal_set__pstatpts(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pStatPts) -} -inline ::uint32_t PlayerData::_internal__pstatpts() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pstatpts_; -} -inline void PlayerData::_internal_set__pstatpts(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pstatpts_ = value; -} - -// uint32 _pDamageMod = 26; -inline void PlayerData::clear__pdamagemod() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdamagemod_ = 0u; -} -inline ::uint32_t PlayerData::_pdamagemod() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pDamageMod) - return _internal__pdamagemod(); -} -inline void PlayerData::set__pdamagemod(::uint32_t value) { - _internal_set__pdamagemod(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pDamageMod) -} -inline ::uint32_t PlayerData::_internal__pdamagemod() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pdamagemod_; -} -inline void PlayerData::_internal_set__pdamagemod(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pdamagemod_ = value; -} - -// uint32 _pHitPoints = 27; -inline void PlayerData::clear__phitpoints() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._phitpoints_ = 0u; -} -inline ::uint32_t PlayerData::_phitpoints() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pHitPoints) - return _internal__phitpoints(); -} -inline void PlayerData::set__phitpoints(::uint32_t value) { - _internal_set__phitpoints(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pHitPoints) -} -inline ::uint32_t PlayerData::_internal__phitpoints() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._phitpoints_; -} -inline void PlayerData::_internal_set__phitpoints(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._phitpoints_ = value; -} - -// uint32 _pMaxHP = 28; -inline void PlayerData::clear__pmaxhp() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmaxhp_ = 0u; -} -inline ::uint32_t PlayerData::_pmaxhp() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMaxHP) - return _internal__pmaxhp(); -} -inline void PlayerData::set__pmaxhp(::uint32_t value) { - _internal_set__pmaxhp(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMaxHP) -} -inline ::uint32_t PlayerData::_internal__pmaxhp() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmaxhp_; -} -inline void PlayerData::_internal_set__pmaxhp(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmaxhp_ = value; -} - -// sint32 _pMana = 29; -inline void PlayerData::clear__pmana() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmana_ = 0; -} -inline ::int32_t PlayerData::_pmana() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMana) - return _internal__pmana(); -} -inline void PlayerData::set__pmana(::int32_t value) { - _internal_set__pmana(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMana) -} -inline ::int32_t PlayerData::_internal__pmana() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmana_; -} -inline void PlayerData::_internal_set__pmana(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmana_ = value; -} - -// uint32 _pMaxMana = 30; -inline void PlayerData::clear__pmaxmana() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmaxmana_ = 0u; -} -inline ::uint32_t PlayerData::_pmaxmana() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMaxMana) - return _internal__pmaxmana(); -} -inline void PlayerData::set__pmaxmana(::uint32_t value) { - _internal_set__pmaxmana(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMaxMana) -} -inline ::uint32_t PlayerData::_internal__pmaxmana() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmaxmana_; -} -inline void PlayerData::_internal_set__pmaxmana(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmaxmana_ = value; -} - -// uint32 _pLevel = 31; -inline void PlayerData::clear__plevel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._plevel_ = 0u; -} -inline ::uint32_t PlayerData::_plevel() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pLevel) - return _internal__plevel(); -} -inline void PlayerData::set__plevel(::uint32_t value) { - _internal_set__plevel(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pLevel) -} -inline ::uint32_t PlayerData::_internal__plevel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._plevel_; -} -inline void PlayerData::_internal_set__plevel(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._plevel_ = value; -} - -// uint32 _pExperience = 32; -inline void PlayerData::clear__pexperience() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pexperience_ = 0u; -} -inline ::uint32_t PlayerData::_pexperience() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pExperience) - return _internal__pexperience(); -} -inline void PlayerData::set__pexperience(::uint32_t value) { - _internal_set__pexperience(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pExperience) -} -inline ::uint32_t PlayerData::_internal__pexperience() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pexperience_; -} -inline void PlayerData::_internal_set__pexperience(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pexperience_ = value; -} - -// uint32 _pArmorClass = 33; -inline void PlayerData::clear__parmorclass() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._parmorclass_ = 0u; -} -inline ::uint32_t PlayerData::_parmorclass() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pArmorClass) - return _internal__parmorclass(); -} -inline void PlayerData::set__parmorclass(::uint32_t value) { - _internal_set__parmorclass(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pArmorClass) -} -inline ::uint32_t PlayerData::_internal__parmorclass() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._parmorclass_; -} -inline void PlayerData::_internal_set__parmorclass(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._parmorclass_ = value; -} - -// uint32 _pMagResist = 34; -inline void PlayerData::clear__pmagresist() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmagresist_ = 0u; -} -inline ::uint32_t PlayerData::_pmagresist() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pMagResist) - return _internal__pmagresist(); -} -inline void PlayerData::set__pmagresist(::uint32_t value) { - _internal_set__pmagresist(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pMagResist) -} -inline ::uint32_t PlayerData::_internal__pmagresist() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pmagresist_; -} -inline void PlayerData::_internal_set__pmagresist(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pmagresist_ = value; -} - -// uint32 _pFireResist = 35; -inline void PlayerData::clear__pfireresist() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfireresist_ = 0u; -} -inline ::uint32_t PlayerData::_pfireresist() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pFireResist) - return _internal__pfireresist(); -} -inline void PlayerData::set__pfireresist(::uint32_t value) { - _internal_set__pfireresist(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pFireResist) -} -inline ::uint32_t PlayerData::_internal__pfireresist() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pfireresist_; -} -inline void PlayerData::_internal_set__pfireresist(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pfireresist_ = value; -} - -// uint32 _pLightResist = 36; -inline void PlayerData::clear__plightresist() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._plightresist_ = 0u; -} -inline ::uint32_t PlayerData::_plightresist() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pLightResist) - return _internal__plightresist(); -} -inline void PlayerData::set__plightresist(::uint32_t value) { - _internal_set__plightresist(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pLightResist) -} -inline ::uint32_t PlayerData::_internal__plightresist() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._plightresist_; -} -inline void PlayerData::_internal_set__plightresist(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._plightresist_ = value; -} - -// uint32 _pGold = 37; -inline void PlayerData::clear__pgold() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pgold_ = 0u; -} -inline ::uint32_t PlayerData::_pgold() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pGold) - return _internal__pgold(); -} -inline void PlayerData::set__pgold(::uint32_t value) { - _internal_set__pgold(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pGold) -} -inline ::uint32_t PlayerData::_internal__pgold() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pgold_; -} -inline void PlayerData::_internal_set__pgold(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pgold_ = value; -} - -// repeated sint32 InvBody = 38; -inline int PlayerData::_internal_invbody_size() const { - return _internal_invbody().size(); -} -inline int PlayerData::invbody_size() const { - return _internal_invbody_size(); -} -inline void PlayerData::clear_invbody() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.invbody_.Clear(); -} -inline ::int32_t PlayerData::invbody(int index) const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvBody) - return _internal_invbody().Get(index); -} -inline void PlayerData::set_invbody(int index, ::int32_t value) { - _internal_mutable_invbody()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvBody) -} -inline void PlayerData::add_invbody(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_invbody()->Add(value); - // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvBody) -} -inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invbody() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvBody) - return _internal_invbody(); -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invbody() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvBody) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_invbody(); -} -inline const ::google::protobuf::RepeatedField<::int32_t>& -PlayerData::_internal_invbody() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.invbody_; -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invbody() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.invbody_; -} - -// repeated sint32 InvList = 39; -inline int PlayerData::_internal_invlist_size() const { - return _internal_invlist().size(); -} -inline int PlayerData::invlist_size() const { - return _internal_invlist_size(); -} -inline void PlayerData::clear_invlist() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.invlist_.Clear(); -} -inline ::int32_t PlayerData::invlist(int index) const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvList) - return _internal_invlist().Get(index); -} -inline void PlayerData::set_invlist(int index, ::int32_t value) { - _internal_mutable_invlist()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvList) -} -inline void PlayerData::add_invlist(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_invlist()->Add(value); - // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvList) -} -inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invlist() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvList) - return _internal_invlist(); -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invlist() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvList) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_invlist(); -} -inline const ::google::protobuf::RepeatedField<::int32_t>& -PlayerData::_internal_invlist() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.invlist_; -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invlist() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.invlist_; -} - -// repeated sint32 InvGrid = 40; -inline int PlayerData::_internal_invgrid_size() const { - return _internal_invgrid().size(); -} -inline int PlayerData::invgrid_size() const { - return _internal_invgrid_size(); -} -inline void PlayerData::clear_invgrid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.invgrid_.Clear(); -} -inline ::int32_t PlayerData::invgrid(int index) const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.InvGrid) - return _internal_invgrid().Get(index); -} -inline void PlayerData::set_invgrid(int index, ::int32_t value) { - _internal_mutable_invgrid()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.InvGrid) -} -inline void PlayerData::add_invgrid(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_invgrid()->Add(value); - // @@protoc_insertion_point(field_add:dapi.data.PlayerData.InvGrid) -} -inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::invgrid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.data.PlayerData.InvGrid) - return _internal_invgrid(); -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_invgrid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.InvGrid) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_invgrid(); -} -inline const ::google::protobuf::RepeatedField<::int32_t>& -PlayerData::_internal_invgrid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.invgrid_; -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_invgrid() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.invgrid_; -} - -// repeated sint32 SpdList = 41; -inline int PlayerData::_internal_spdlist_size() const { - return _internal_spdlist().size(); -} -inline int PlayerData::spdlist_size() const { - return _internal_spdlist_size(); -} -inline void PlayerData::clear_spdlist() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.spdlist_.Clear(); -} -inline ::int32_t PlayerData::spdlist(int index) const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.SpdList) - return _internal_spdlist().Get(index); -} -inline void PlayerData::set_spdlist(int index, ::int32_t value) { - _internal_mutable_spdlist()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.SpdList) -} -inline void PlayerData::add_spdlist(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_spdlist()->Add(value); - // @@protoc_insertion_point(field_add:dapi.data.PlayerData.SpdList) -} -inline const ::google::protobuf::RepeatedField<::int32_t>& PlayerData::spdlist() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.data.PlayerData.SpdList) - return _internal_spdlist(); -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::mutable_spdlist() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.data.PlayerData.SpdList) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_spdlist(); -} -inline const ::google::protobuf::RepeatedField<::int32_t>& -PlayerData::_internal_spdlist() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.spdlist_; -} -inline ::google::protobuf::RepeatedField<::int32_t>* PlayerData::_internal_mutable_spdlist() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.spdlist_; -} - -// sint32 HoldItem = 42; -inline void PlayerData::clear_holditem() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.holditem_ = 0; -} -inline ::int32_t PlayerData::holditem() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.HoldItem) - return _internal_holditem(); -} -inline void PlayerData::set_holditem(::int32_t value) { - _internal_set_holditem(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.HoldItem) -} -inline ::int32_t PlayerData::_internal_holditem() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.holditem_; -} -inline void PlayerData::_internal_set_holditem(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.holditem_ = value; -} - -// uint32 _pIAC = 43; -inline void PlayerData::clear__piac() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._piac_ = 0u; -} -inline ::uint32_t PlayerData::_piac() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIAC) - return _internal__piac(); -} -inline void PlayerData::set__piac(::uint32_t value) { - _internal_set__piac(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIAC) -} -inline ::uint32_t PlayerData::_internal__piac() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._piac_; -} -inline void PlayerData::_internal_set__piac(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._piac_ = value; -} - -// uint32 _pIMinDam = 44; -inline void PlayerData::clear__pimindam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pimindam_ = 0u; -} -inline ::uint32_t PlayerData::_pimindam() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIMinDam) - return _internal__pimindam(); -} -inline void PlayerData::set__pimindam(::uint32_t value) { - _internal_set__pimindam(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIMinDam) -} -inline ::uint32_t PlayerData::_internal__pimindam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pimindam_; -} -inline void PlayerData::_internal_set__pimindam(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pimindam_ = value; -} - -// uint32 _pIMaxDam = 45; -inline void PlayerData::clear__pimaxdam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pimaxdam_ = 0u; -} -inline ::uint32_t PlayerData::_pimaxdam() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIMaxDam) - return _internal__pimaxdam(); -} -inline void PlayerData::set__pimaxdam(::uint32_t value) { - _internal_set__pimaxdam(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIMaxDam) -} -inline ::uint32_t PlayerData::_internal__pimaxdam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pimaxdam_; -} -inline void PlayerData::_internal_set__pimaxdam(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pimaxdam_ = value; -} - -// uint32 _pIBonusDam = 46; -inline void PlayerData::clear__pibonusdam() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusdam_ = 0u; -} -inline ::uint32_t PlayerData::_pibonusdam() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusDam) - return _internal__pibonusdam(); -} -inline void PlayerData::set__pibonusdam(::uint32_t value) { - _internal_set__pibonusdam(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusDam) -} -inline ::uint32_t PlayerData::_internal__pibonusdam() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pibonusdam_; -} -inline void PlayerData::_internal_set__pibonusdam(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusdam_ = value; -} - -// uint32 _pIBonusToHit = 47; -inline void PlayerData::clear__pibonustohit() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonustohit_ = 0u; -} -inline ::uint32_t PlayerData::_pibonustohit() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusToHit) - return _internal__pibonustohit(); -} -inline void PlayerData::set__pibonustohit(::uint32_t value) { - _internal_set__pibonustohit(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusToHit) -} -inline ::uint32_t PlayerData::_internal__pibonustohit() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pibonustohit_; -} -inline void PlayerData::_internal_set__pibonustohit(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonustohit_ = value; -} - -// uint32 _pIBonusAC = 48; -inline void PlayerData::clear__pibonusac() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusac_ = 0u; -} -inline ::uint32_t PlayerData::_pibonusac() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusAC) - return _internal__pibonusac(); -} -inline void PlayerData::set__pibonusac(::uint32_t value) { - _internal_set__pibonusac(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusAC) -} -inline ::uint32_t PlayerData::_internal__pibonusac() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pibonusac_; -} -inline void PlayerData::_internal_set__pibonusac(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusac_ = value; -} - -// uint32 _pIBonusDamMod = 49; -inline void PlayerData::clear__pibonusdammod() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusdammod_ = 0u; -} -inline ::uint32_t PlayerData::_pibonusdammod() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData._pIBonusDamMod) - return _internal__pibonusdammod(); -} -inline void PlayerData::set__pibonusdammod(::uint32_t value) { - _internal_set__pibonusdammod(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData._pIBonusDamMod) -} -inline ::uint32_t PlayerData::_internal__pibonusdammod() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_._pibonusdammod_; -} -inline void PlayerData::_internal_set__pibonusdammod(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_._pibonusdammod_ = value; -} - -// bool pManaShield = 50; -inline void PlayerData::clear_pmanashield() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pmanashield_ = false; -} -inline bool PlayerData::pmanashield() const { - // @@protoc_insertion_point(field_get:dapi.data.PlayerData.pManaShield) - return _internal_pmanashield(); -} -inline void PlayerData::set_pmanashield(bool value) { - _internal_set_pmanashield(value); - // @@protoc_insertion_point(field_set:dapi.data.PlayerData.pManaShield) -} -inline bool PlayerData::_internal_pmanashield() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pmanashield_; -} -inline void PlayerData::_internal_set_pmanashield(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pmanashield_ = value; -} - -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ - -// @@protoc_insertion_point(namespace_scope) -} // namespace data -} // namespace dapi - - -// @@protoc_insertion_point(global_scope) - -#include "google/protobuf/port_undef.inc" - -#endif // data_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/game.pb.cc b/Source/dapi/Backend/Messages/generated/game.pb.cc deleted file mode 100644 index 257690ffa..000000000 --- a/Source/dapi/Backend/Messages/generated/game.pb.cc +++ /dev/null @@ -1,1115 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: game.proto -// Protobuf C++ Version: 5.29.3 - -#include "game.pb.h" - -#include -#include -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/generated_message_tctable_impl.h" -#include "google/protobuf/extension_set.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/wire_format_lite.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" -PROTOBUF_PRAGMA_INIT_SEG -namespace _pb = ::google::protobuf; -namespace _pbi = ::google::protobuf::internal; -namespace _fl = ::google::protobuf::internal::field_layout; -namespace dapi { -namespace game { - -inline constexpr FrameUpdate::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : dpiece_{}, - playerdata_{}, - itemdata_{}, - grounditemid_{}, - _grounditemid_cached_byte_size_{0}, - townerdata_{}, - storeoption_{}, - _storeoption_cached_byte_size_{0}, - storeitems_{}, - _storeitems_cached_byte_size_{0}, - triggerdata_{}, - monsterdata_{}, - objectdata_{}, - missiledata_{}, - portaldata_{}, - questdata_{}, - qtext_( - &::google::protobuf::internal::fixed_address_empty_string, - ::_pbi::ConstantInitialized()), - player_{0u}, - stextflag_{0}, - pausemode_{0}, - cursor_{0u}, - menuopen_{false}, - chrflag_{false}, - invflag_{false}, - qtextflag_{false}, - currlevel_{0u}, - setlevel_{false}, - fps_{0u}, - gamemode_{0u}, - gndifficulty_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR FrameUpdate::FrameUpdate(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct FrameUpdateDefaultTypeInternal { - PROTOBUF_CONSTEXPR FrameUpdateDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~FrameUpdateDefaultTypeInternal() {} - union { - FrameUpdate _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 FrameUpdateDefaultTypeInternal _FrameUpdate_default_instance_; -} // namespace game -} // namespace dapi -namespace dapi { -namespace game { -// =================================================================== - -class FrameUpdate::_Internal { - public: -}; - -void FrameUpdate::clear_dpiece() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.dpiece_.Clear(); -} -void FrameUpdate::clear_playerdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.playerdata_.Clear(); -} -void FrameUpdate::clear_itemdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.itemdata_.Clear(); -} -void FrameUpdate::clear_townerdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.townerdata_.Clear(); -} -void FrameUpdate::clear_triggerdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.triggerdata_.Clear(); -} -void FrameUpdate::clear_monsterdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.monsterdata_.Clear(); -} -void FrameUpdate::clear_objectdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.objectdata_.Clear(); -} -void FrameUpdate::clear_missiledata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.missiledata_.Clear(); -} -void FrameUpdate::clear_portaldata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.portaldata_.Clear(); -} -void FrameUpdate::clear_questdata() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.questdata_.Clear(); -} -FrameUpdate::FrameUpdate(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.game.FrameUpdate) -} -inline PROTOBUF_NDEBUG_INLINE FrameUpdate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::game::FrameUpdate& from_msg) - : dpiece_{visibility, arena, from.dpiece_}, - playerdata_{visibility, arena, from.playerdata_}, - itemdata_{visibility, arena, from.itemdata_}, - grounditemid_{visibility, arena, from.grounditemid_}, - _grounditemid_cached_byte_size_{0}, - townerdata_{visibility, arena, from.townerdata_}, - storeoption_{visibility, arena, from.storeoption_}, - _storeoption_cached_byte_size_{0}, - storeitems_{visibility, arena, from.storeitems_}, - _storeitems_cached_byte_size_{0}, - triggerdata_{visibility, arena, from.triggerdata_}, - monsterdata_{visibility, arena, from.monsterdata_}, - objectdata_{visibility, arena, from.objectdata_}, - missiledata_{visibility, arena, from.missiledata_}, - portaldata_{visibility, arena, from.portaldata_}, - questdata_{visibility, arena, from.questdata_}, - qtext_(arena, from.qtext_), - _cached_size_{0} {} - -FrameUpdate::FrameUpdate( - ::google::protobuf::Arena* arena, - const FrameUpdate& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - FrameUpdate* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - ::memcpy(reinterpret_cast(&_impl_) + - offsetof(Impl_, player_), - reinterpret_cast(&from._impl_) + - offsetof(Impl_, player_), - offsetof(Impl_, gndifficulty_) - - offsetof(Impl_, player_) + - sizeof(Impl_::gndifficulty_)); - - // @@protoc_insertion_point(copy_constructor:dapi.game.FrameUpdate) -} -inline PROTOBUF_NDEBUG_INLINE FrameUpdate::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : dpiece_{visibility, arena}, - playerdata_{visibility, arena}, - itemdata_{visibility, arena}, - grounditemid_{visibility, arena}, - _grounditemid_cached_byte_size_{0}, - townerdata_{visibility, arena}, - storeoption_{visibility, arena}, - _storeoption_cached_byte_size_{0}, - storeitems_{visibility, arena}, - _storeitems_cached_byte_size_{0}, - triggerdata_{visibility, arena}, - monsterdata_{visibility, arena}, - objectdata_{visibility, arena}, - missiledata_{visibility, arena}, - portaldata_{visibility, arena}, - questdata_{visibility, arena}, - qtext_(arena), - _cached_size_{0} {} - -inline void FrameUpdate::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - ::memset(reinterpret_cast(&_impl_) + - offsetof(Impl_, player_), - 0, - offsetof(Impl_, gndifficulty_) - - offsetof(Impl_, player_) + - sizeof(Impl_::gndifficulty_)); -} -FrameUpdate::~FrameUpdate() { - // @@protoc_insertion_point(destructor:dapi.game.FrameUpdate) - SharedDtor(*this); -} -inline void FrameUpdate::SharedDtor(MessageLite& self) { - FrameUpdate& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.qtext_.Destroy(); - this_._impl_.~Impl_(); -} - -inline void* FrameUpdate::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) FrameUpdate(arena); -} -constexpr auto FrameUpdate::InternalNewImpl_() { - constexpr auto arena_bits = ::google::protobuf::internal::EncodePlacementArenaOffsets({ - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_) + - decltype(FrameUpdate::_impl_.dpiece_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_) + - decltype(FrameUpdate::_impl_.playerdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_) + - decltype(FrameUpdate::_impl_.itemdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_) + - decltype(FrameUpdate::_impl_.grounditemid_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_) + - decltype(FrameUpdate::_impl_.townerdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_) + - decltype(FrameUpdate::_impl_.storeoption_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_) + - decltype(FrameUpdate::_impl_.storeitems_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_) + - decltype(FrameUpdate::_impl_.triggerdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_) + - decltype(FrameUpdate::_impl_.monsterdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_) + - decltype(FrameUpdate::_impl_.objectdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_) + - decltype(FrameUpdate::_impl_.missiledata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_) + - decltype(FrameUpdate::_impl_.portaldata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_) + - decltype(FrameUpdate::_impl_.questdata_):: - InternalGetArenaOffset( - ::google::protobuf::MessageLite::internal_visibility()), - }); - if (arena_bits.has_value()) { - return ::google::protobuf::internal::MessageCreator::CopyInit( - sizeof(FrameUpdate), alignof(FrameUpdate), *arena_bits); - } else { - return ::google::protobuf::internal::MessageCreator(&FrameUpdate::PlacementNew_, - sizeof(FrameUpdate), - alignof(FrameUpdate)); - } -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<22> FrameUpdate::_class_data_ = { - { - &_FrameUpdate_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &FrameUpdate::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &FrameUpdate::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &FrameUpdate::ByteSizeLong, - &FrameUpdate::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_._cached_size_), - true, - }, - "dapi.game.FrameUpdate", -}; -const ::google::protobuf::internal::ClassData* FrameUpdate::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<5, 27, 10, 59, 2> FrameUpdate::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 27, 248, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4160749568, // skipmap - offsetof(decltype(_table_), field_entries), - 27, // num_field_entries - 10, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::game::FrameUpdate>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - // uint32 player = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_)}}, - // sint32 stextflag = 2; - {::_pbi::TcParser::FastZ32S1, - {16, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.stextflag_)}}, - // sint32 pauseMode = 3; - {::_pbi::TcParser::FastZ32S1, - {24, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.pausemode_)}}, - // bool menuOpen = 4; - {::_pbi::TcParser::FastV8S1, - {32, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.menuopen_)}}, - // uint32 cursor = 5; - {::_pbi::TcParser::FastV32S1, - {40, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.cursor_)}}, - // bool chrflag = 6; - {::_pbi::TcParser::FastV8S1, - {48, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.chrflag_)}}, - // bool invflag = 7; - {::_pbi::TcParser::FastV8S1, - {56, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.invflag_)}}, - // bool qtextflag = 8; - {::_pbi::TcParser::FastV8S1, - {64, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtextflag_)}}, - // string qtext = 9; - {::_pbi::TcParser::FastUS1, - {74, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtext_)}}, - // uint32 currlevel = 10; - {::_pbi::TcParser::FastV32S1, - {80, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.currlevel_)}}, - // bool setlevel = 11; - {::_pbi::TcParser::FastV8S1, - {88, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.setlevel_)}}, - // uint32 fps = 12; - {::_pbi::TcParser::FastV32S1, - {96, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.fps_)}}, - // uint32 gameMode = 13; - {::_pbi::TcParser::FastV32S1, - {104, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gamemode_)}}, - // uint32 gnDifficulty = 14; - {::_pbi::TcParser::FastV32S1, - {112, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_)}}, - // repeated .dapi.data.TileData dPiece = 15; - {::_pbi::TcParser::FastMtR1, - {122, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_)}}, - // repeated .dapi.data.PlayerData playerData = 16; - {::_pbi::TcParser::FastMtR2, - {386, 63, 1, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_)}}, - // repeated .dapi.data.ItemData itemData = 17; - {::_pbi::TcParser::FastMtR2, - {394, 63, 2, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_)}}, - // repeated uint32 groundItemID = 18; - {::_pbi::TcParser::FastV32P2, - {402, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_)}}, - // repeated .dapi.data.TownerData townerData = 19; - {::_pbi::TcParser::FastMtR2, - {410, 63, 3, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_)}}, - // repeated uint32 storeOption = 20; - {::_pbi::TcParser::FastV32P2, - {418, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_)}}, - // repeated uint32 storeItems = 21; - {::_pbi::TcParser::FastV32P2, - {426, 63, 0, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_)}}, - // repeated .dapi.data.TriggerData triggerData = 22; - {::_pbi::TcParser::FastMtR2, - {434, 63, 4, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_)}}, - // repeated .dapi.data.MonsterData monsterData = 23; - {::_pbi::TcParser::FastMtR2, - {442, 63, 5, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_)}}, - // repeated .dapi.data.ObjectData objectData = 24; - {::_pbi::TcParser::FastMtR2, - {450, 63, 6, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_)}}, - // repeated .dapi.data.MissileData missileData = 25; - {::_pbi::TcParser::FastMtR2, - {458, 63, 7, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_)}}, - // repeated .dapi.data.PortalData portalData = 26; - {::_pbi::TcParser::FastMtR2, - {466, 63, 8, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_)}}, - // repeated .dapi.data.QuestData questData = 27; - {::_pbi::TcParser::FastMtR2, - {474, 63, 9, PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_)}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 player = 1; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // sint32 stextflag = 2; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.stextflag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // sint32 pauseMode = 3; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.pausemode_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kSInt32)}, - // bool menuOpen = 4; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.menuopen_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // uint32 cursor = 5; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.cursor_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // bool chrflag = 6; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.chrflag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // bool invflag = 7; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.invflag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // bool qtextflag = 8; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtextflag_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // string qtext = 9; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.qtext_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUtf8String | ::_fl::kRepAString)}, - // uint32 currlevel = 10; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.currlevel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // bool setlevel = 11; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.setlevel_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kBool)}, - // uint32 fps = 12; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.fps_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 gameMode = 13; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gamemode_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // uint32 gnDifficulty = 14; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - // repeated .dapi.data.TileData dPiece = 15; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.dpiece_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.PlayerData playerData = 16; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.playerdata_), 0, 1, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.ItemData itemData = 17; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.itemdata_), 0, 2, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated uint32 groundItemID = 18; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.grounditemid_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, - // repeated .dapi.data.TownerData townerData = 19; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.townerdata_), 0, 3, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated uint32 storeOption = 20; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeoption_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, - // repeated uint32 storeItems = 21; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.storeitems_), 0, 0, - (0 | ::_fl::kFcRepeated | ::_fl::kPackedUInt32)}, - // repeated .dapi.data.TriggerData triggerData = 22; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.triggerdata_), 0, 4, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.MonsterData monsterData = 23; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.monsterdata_), 0, 5, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.ObjectData objectData = 24; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.objectdata_), 0, 6, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.MissileData missileData = 25; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.missiledata_), 0, 7, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.PortalData portalData = 26; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.portaldata_), 0, 8, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - // repeated .dapi.data.QuestData questData = 27; - {PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.questdata_), 0, 9, - (0 | ::_fl::kFcRepeated | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, {{ - {::_pbi::TcParser::GetTable<::dapi::data::TileData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::PlayerData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::ItemData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::TownerData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::TriggerData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::MonsterData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::ObjectData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::MissileData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::PortalData>()}, - {::_pbi::TcParser::GetTable<::dapi::data::QuestData>()}, - }}, {{ - "\25\0\0\0\0\0\0\0\0\5\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" - "dapi.game.FrameUpdate" - "qtext" - }}, -}; - -PROTOBUF_NOINLINE void FrameUpdate::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.game.FrameUpdate) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.dpiece_.Clear(); - _impl_.playerdata_.Clear(); - _impl_.itemdata_.Clear(); - _impl_.grounditemid_.Clear(); - _impl_.townerdata_.Clear(); - _impl_.storeoption_.Clear(); - _impl_.storeitems_.Clear(); - _impl_.triggerdata_.Clear(); - _impl_.monsterdata_.Clear(); - _impl_.objectdata_.Clear(); - _impl_.missiledata_.Clear(); - _impl_.portaldata_.Clear(); - _impl_.questdata_.Clear(); - _impl_.qtext_.ClearToEmpty(); - ::memset(&_impl_.player_, 0, static_cast<::size_t>( - reinterpret_cast(&_impl_.gndifficulty_) - - reinterpret_cast(&_impl_.player_)) + sizeof(_impl_.gndifficulty_)); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* FrameUpdate::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const FrameUpdate& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* FrameUpdate::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const FrameUpdate& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.game.FrameUpdate) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 player = 1; - if (this_._internal_player() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_player(), target); - } - - // sint32 stextflag = 2; - if (this_._internal_stextflag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 2, this_._internal_stextflag(), target); - } - - // sint32 pauseMode = 3; - if (this_._internal_pausemode() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteSInt32ToArray( - 3, this_._internal_pausemode(), target); - } - - // bool menuOpen = 4; - if (this_._internal_menuopen() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 4, this_._internal_menuopen(), target); - } - - // uint32 cursor = 5; - if (this_._internal_cursor() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 5, this_._internal_cursor(), target); - } - - // bool chrflag = 6; - if (this_._internal_chrflag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 6, this_._internal_chrflag(), target); - } - - // bool invflag = 7; - if (this_._internal_invflag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 7, this_._internal_invflag(), target); - } - - // bool qtextflag = 8; - if (this_._internal_qtextflag() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 8, this_._internal_qtextflag(), target); - } - - // string qtext = 9; - if (!this_._internal_qtext().empty()) { - const std::string& _s = this_._internal_qtext(); - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - _s.data(), static_cast(_s.length()), ::google::protobuf::internal::WireFormatLite::SERIALIZE, "dapi.game.FrameUpdate.qtext"); - target = stream->WriteStringMaybeAliased(9, _s, target); - } - - // uint32 currlevel = 10; - if (this_._internal_currlevel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 10, this_._internal_currlevel(), target); - } - - // bool setlevel = 11; - if (this_._internal_setlevel() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteBoolToArray( - 11, this_._internal_setlevel(), target); - } - - // uint32 fps = 12; - if (this_._internal_fps() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 12, this_._internal_fps(), target); - } - - // uint32 gameMode = 13; - if (this_._internal_gamemode() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 13, this_._internal_gamemode(), target); - } - - // uint32 gnDifficulty = 14; - if (this_._internal_gndifficulty() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 14, this_._internal_gndifficulty(), target); - } - - // repeated .dapi.data.TileData dPiece = 15; - for (unsigned i = 0, n = static_cast( - this_._internal_dpiece_size()); - i < n; i++) { - const auto& repfield = this_._internal_dpiece().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 15, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.PlayerData playerData = 16; - for (unsigned i = 0, n = static_cast( - this_._internal_playerdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_playerdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 16, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.ItemData itemData = 17; - for (unsigned i = 0, n = static_cast( - this_._internal_itemdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_itemdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 17, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated uint32 groundItemID = 18; - { - int byte_size = this_._impl_._grounditemid_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 18, this_._internal_grounditemid(), byte_size, target); - } - } - - // repeated .dapi.data.TownerData townerData = 19; - for (unsigned i = 0, n = static_cast( - this_._internal_townerdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_townerdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 19, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated uint32 storeOption = 20; - { - int byte_size = this_._impl_._storeoption_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 20, this_._internal_storeoption(), byte_size, target); - } - } - - // repeated uint32 storeItems = 21; - { - int byte_size = this_._impl_._storeitems_cached_byte_size_.Get(); - if (byte_size > 0) { - target = stream->WriteUInt32Packed( - 21, this_._internal_storeitems(), byte_size, target); - } - } - - // repeated .dapi.data.TriggerData triggerData = 22; - for (unsigned i = 0, n = static_cast( - this_._internal_triggerdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_triggerdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 22, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.MonsterData monsterData = 23; - for (unsigned i = 0, n = static_cast( - this_._internal_monsterdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_monsterdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 23, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.ObjectData objectData = 24; - for (unsigned i = 0, n = static_cast( - this_._internal_objectdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_objectdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 24, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.MissileData missileData = 25; - for (unsigned i = 0, n = static_cast( - this_._internal_missiledata_size()); - i < n; i++) { - const auto& repfield = this_._internal_missiledata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 25, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.PortalData portalData = 26; - for (unsigned i = 0, n = static_cast( - this_._internal_portaldata_size()); - i < n; i++) { - const auto& repfield = this_._internal_portaldata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 26, repfield, repfield.GetCachedSize(), - target, stream); - } - - // repeated .dapi.data.QuestData questData = 27; - for (unsigned i = 0, n = static_cast( - this_._internal_questdata_size()); - i < n; i++) { - const auto& repfield = this_._internal_questdata().Get(i); - target = - ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 27, repfield, repfield.GetCachedSize(), - target, stream); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.game.FrameUpdate) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t FrameUpdate::ByteSizeLong(const MessageLite& base) { - const FrameUpdate& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t FrameUpdate::ByteSizeLong() const { - const FrameUpdate& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.game.FrameUpdate) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - ::_pbi::Prefetch5LinesFrom7Lines(&this_); - { - // repeated .dapi.data.TileData dPiece = 15; - { - total_size += 1UL * this_._internal_dpiece_size(); - for (const auto& msg : this_._internal_dpiece()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.PlayerData playerData = 16; - { - total_size += 2UL * this_._internal_playerdata_size(); - for (const auto& msg : this_._internal_playerdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.ItemData itemData = 17; - { - total_size += 2UL * this_._internal_itemdata_size(); - for (const auto& msg : this_._internal_itemdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated uint32 groundItemID = 18; - { - total_size += - ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( - this_._internal_grounditemid(), 2, - this_._impl_._grounditemid_cached_byte_size_); - } - // repeated .dapi.data.TownerData townerData = 19; - { - total_size += 2UL * this_._internal_townerdata_size(); - for (const auto& msg : this_._internal_townerdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated uint32 storeOption = 20; - { - total_size += - ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( - this_._internal_storeoption(), 2, - this_._impl_._storeoption_cached_byte_size_); - } - // repeated uint32 storeItems = 21; - { - total_size += - ::_pbi::WireFormatLite::UInt32SizeWithPackedTagSize( - this_._internal_storeitems(), 2, - this_._impl_._storeitems_cached_byte_size_); - } - // repeated .dapi.data.TriggerData triggerData = 22; - { - total_size += 2UL * this_._internal_triggerdata_size(); - for (const auto& msg : this_._internal_triggerdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.MonsterData monsterData = 23; - { - total_size += 2UL * this_._internal_monsterdata_size(); - for (const auto& msg : this_._internal_monsterdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.ObjectData objectData = 24; - { - total_size += 2UL * this_._internal_objectdata_size(); - for (const auto& msg : this_._internal_objectdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.MissileData missileData = 25; - { - total_size += 2UL * this_._internal_missiledata_size(); - for (const auto& msg : this_._internal_missiledata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.PortalData portalData = 26; - { - total_size += 2UL * this_._internal_portaldata_size(); - for (const auto& msg : this_._internal_portaldata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - // repeated .dapi.data.QuestData questData = 27; - { - total_size += 2UL * this_._internal_questdata_size(); - for (const auto& msg : this_._internal_questdata()) { - total_size += ::google::protobuf::internal::WireFormatLite::MessageSize(msg); - } - } - } - { - // string qtext = 9; - if (!this_._internal_qtext().empty()) { - total_size += 1 + ::google::protobuf::internal::WireFormatLite::StringSize( - this_._internal_qtext()); - } - // uint32 player = 1; - if (this_._internal_player() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_player()); - } - // sint32 stextflag = 2; - if (this_._internal_stextflag() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_stextflag()); - } - // sint32 pauseMode = 3; - if (this_._internal_pausemode() != 0) { - total_size += ::_pbi::WireFormatLite::SInt32SizePlusOne( - this_._internal_pausemode()); - } - // uint32 cursor = 5; - if (this_._internal_cursor() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_cursor()); - } - // bool menuOpen = 4; - if (this_._internal_menuopen() != 0) { - total_size += 2; - } - // bool chrflag = 6; - if (this_._internal_chrflag() != 0) { - total_size += 2; - } - // bool invflag = 7; - if (this_._internal_invflag() != 0) { - total_size += 2; - } - // bool qtextflag = 8; - if (this_._internal_qtextflag() != 0) { - total_size += 2; - } - // uint32 currlevel = 10; - if (this_._internal_currlevel() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_currlevel()); - } - // bool setlevel = 11; - if (this_._internal_setlevel() != 0) { - total_size += 2; - } - // uint32 fps = 12; - if (this_._internal_fps() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_fps()); - } - // uint32 gameMode = 13; - if (this_._internal_gamemode() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_gamemode()); - } - // uint32 gnDifficulty = 14; - if (this_._internal_gndifficulty() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_gndifficulty()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void FrameUpdate::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.game.FrameUpdate) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_mutable_dpiece()->MergeFrom( - from._internal_dpiece()); - _this->_internal_mutable_playerdata()->MergeFrom( - from._internal_playerdata()); - _this->_internal_mutable_itemdata()->MergeFrom( - from._internal_itemdata()); - _this->_internal_mutable_grounditemid()->MergeFrom(from._internal_grounditemid()); - _this->_internal_mutable_townerdata()->MergeFrom( - from._internal_townerdata()); - _this->_internal_mutable_storeoption()->MergeFrom(from._internal_storeoption()); - _this->_internal_mutable_storeitems()->MergeFrom(from._internal_storeitems()); - _this->_internal_mutable_triggerdata()->MergeFrom( - from._internal_triggerdata()); - _this->_internal_mutable_monsterdata()->MergeFrom( - from._internal_monsterdata()); - _this->_internal_mutable_objectdata()->MergeFrom( - from._internal_objectdata()); - _this->_internal_mutable_missiledata()->MergeFrom( - from._internal_missiledata()); - _this->_internal_mutable_portaldata()->MergeFrom( - from._internal_portaldata()); - _this->_internal_mutable_questdata()->MergeFrom( - from._internal_questdata()); - if (!from._internal_qtext().empty()) { - _this->_internal_set_qtext(from._internal_qtext()); - } - if (from._internal_player() != 0) { - _this->_impl_.player_ = from._impl_.player_; - } - if (from._internal_stextflag() != 0) { - _this->_impl_.stextflag_ = from._impl_.stextflag_; - } - if (from._internal_pausemode() != 0) { - _this->_impl_.pausemode_ = from._impl_.pausemode_; - } - if (from._internal_cursor() != 0) { - _this->_impl_.cursor_ = from._impl_.cursor_; - } - if (from._internal_menuopen() != 0) { - _this->_impl_.menuopen_ = from._impl_.menuopen_; - } - if (from._internal_chrflag() != 0) { - _this->_impl_.chrflag_ = from._impl_.chrflag_; - } - if (from._internal_invflag() != 0) { - _this->_impl_.invflag_ = from._impl_.invflag_; - } - if (from._internal_qtextflag() != 0) { - _this->_impl_.qtextflag_ = from._impl_.qtextflag_; - } - if (from._internal_currlevel() != 0) { - _this->_impl_.currlevel_ = from._impl_.currlevel_; - } - if (from._internal_setlevel() != 0) { - _this->_impl_.setlevel_ = from._impl_.setlevel_; - } - if (from._internal_fps() != 0) { - _this->_impl_.fps_ = from._impl_.fps_; - } - if (from._internal_gamemode() != 0) { - _this->_impl_.gamemode_ = from._impl_.gamemode_; - } - if (from._internal_gndifficulty() != 0) { - _this->_impl_.gndifficulty_ = from._impl_.gndifficulty_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void FrameUpdate::CopyFrom(const FrameUpdate& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.game.FrameUpdate) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void FrameUpdate::InternalSwap(FrameUpdate* PROTOBUF_RESTRICT other) { - using std::swap; - auto* arena = GetArena(); - ABSL_DCHECK_EQ(arena, other->GetArena()); - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - _impl_.dpiece_.InternalSwap(&other->_impl_.dpiece_); - _impl_.playerdata_.InternalSwap(&other->_impl_.playerdata_); - _impl_.itemdata_.InternalSwap(&other->_impl_.itemdata_); - _impl_.grounditemid_.InternalSwap(&other->_impl_.grounditemid_); - _impl_.townerdata_.InternalSwap(&other->_impl_.townerdata_); - _impl_.storeoption_.InternalSwap(&other->_impl_.storeoption_); - _impl_.storeitems_.InternalSwap(&other->_impl_.storeitems_); - _impl_.triggerdata_.InternalSwap(&other->_impl_.triggerdata_); - _impl_.monsterdata_.InternalSwap(&other->_impl_.monsterdata_); - _impl_.objectdata_.InternalSwap(&other->_impl_.objectdata_); - _impl_.missiledata_.InternalSwap(&other->_impl_.missiledata_); - _impl_.portaldata_.InternalSwap(&other->_impl_.portaldata_); - _impl_.questdata_.InternalSwap(&other->_impl_.questdata_); - ::_pbi::ArenaStringPtr::InternalSwap(&_impl_.qtext_, &other->_impl_.qtext_, arena); - ::google::protobuf::internal::memswap< - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.gndifficulty_) - + sizeof(FrameUpdate::_impl_.gndifficulty_) - - PROTOBUF_FIELD_OFFSET(FrameUpdate, _impl_.player_)>( - reinterpret_cast(&_impl_.player_), - reinterpret_cast(&other->_impl_.player_)); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace game -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google -// @@protoc_insertion_point(global_scope) -#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/game.pb.h b/Source/dapi/Backend/Messages/generated/game.pb.h deleted file mode 100644 index c4c7909e1..000000000 --- a/Source/dapi/Backend/Messages/generated/game.pb.h +++ /dev/null @@ -1,1609 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: game.proto -// Protobuf C++ Version: 5.29.3 - -#ifndef game_2eproto_2epb_2eh -#define game_2eproto_2epb_2eh - -#include -#include -#include -#include - -#include "google/protobuf/runtime_version.h" -#if PROTOBUF_VERSION != 5029003 -#error "Protobuf C++ gencode is built with an incompatible version of" -#error "Protobuf C++ headers/runtime. See" -#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" -#endif -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/arena.h" -#include "google/protobuf/arenastring.h" -#include "google/protobuf/generated_message_tctable_decl.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/metadata_lite.h" -#include "google/protobuf/message_lite.h" -#include "google/protobuf/repeated_field.h" // IWYU pragma: export -#include "google/protobuf/extension_set.h" // IWYU pragma: export -#include "data.pb.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" - -#define PROTOBUF_INTERNAL_EXPORT_game_2eproto - -namespace google { -namespace protobuf { -namespace internal { -template -::absl::string_view GetAnyMessageName(); -} // namespace internal -} // namespace protobuf -} // namespace google - -// Internal implementation detail -- do not use these members. -struct TableStruct_game_2eproto { - static const ::uint32_t offsets[]; -}; -namespace dapi { -namespace game { -class FrameUpdate; -struct FrameUpdateDefaultTypeInternal; -extern FrameUpdateDefaultTypeInternal _FrameUpdate_default_instance_; -} // namespace game -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google - -namespace dapi { -namespace game { - -// =================================================================== - - -// ------------------------------------------------------------------- - -class FrameUpdate final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.game.FrameUpdate) */ { - public: - inline FrameUpdate() : FrameUpdate(nullptr) {} - ~FrameUpdate() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(FrameUpdate* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(FrameUpdate)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR FrameUpdate( - ::google::protobuf::internal::ConstantInitialized); - - inline FrameUpdate(const FrameUpdate& from) : FrameUpdate(nullptr, from) {} - inline FrameUpdate(FrameUpdate&& from) noexcept - : FrameUpdate(nullptr, std::move(from)) {} - inline FrameUpdate& operator=(const FrameUpdate& from) { - CopyFrom(from); - return *this; - } - inline FrameUpdate& operator=(FrameUpdate&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const FrameUpdate& default_instance() { - return *internal_default_instance(); - } - static inline const FrameUpdate* internal_default_instance() { - return reinterpret_cast( - &_FrameUpdate_default_instance_); - } - static constexpr int kIndexInFileMessages = 0; - friend void swap(FrameUpdate& a, FrameUpdate& b) { a.Swap(&b); } - inline void Swap(FrameUpdate* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(FrameUpdate* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - FrameUpdate* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const FrameUpdate& from); - void MergeFrom(const FrameUpdate& from) { FrameUpdate::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(FrameUpdate* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.game.FrameUpdate"; } - - protected: - explicit FrameUpdate(::google::protobuf::Arena* arena); - FrameUpdate(::google::protobuf::Arena* arena, const FrameUpdate& from); - FrameUpdate(::google::protobuf::Arena* arena, FrameUpdate&& from) noexcept - : FrameUpdate(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<22> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kDPieceFieldNumber = 15, - kPlayerDataFieldNumber = 16, - kItemDataFieldNumber = 17, - kGroundItemIDFieldNumber = 18, - kTownerDataFieldNumber = 19, - kStoreOptionFieldNumber = 20, - kStoreItemsFieldNumber = 21, - kTriggerDataFieldNumber = 22, - kMonsterDataFieldNumber = 23, - kObjectDataFieldNumber = 24, - kMissileDataFieldNumber = 25, - kPortalDataFieldNumber = 26, - kQuestDataFieldNumber = 27, - kQtextFieldNumber = 9, - kPlayerFieldNumber = 1, - kStextflagFieldNumber = 2, - kPauseModeFieldNumber = 3, - kCursorFieldNumber = 5, - kMenuOpenFieldNumber = 4, - kChrflagFieldNumber = 6, - kInvflagFieldNumber = 7, - kQtextflagFieldNumber = 8, - kCurrlevelFieldNumber = 10, - kSetlevelFieldNumber = 11, - kFpsFieldNumber = 12, - kGameModeFieldNumber = 13, - kGnDifficultyFieldNumber = 14, - }; - // repeated .dapi.data.TileData dPiece = 15; - int dpiece_size() const; - private: - int _internal_dpiece_size() const; - - public: - void clear_dpiece() ; - ::dapi::data::TileData* mutable_dpiece(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* mutable_dpiece(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& _internal_dpiece() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* _internal_mutable_dpiece(); - public: - const ::dapi::data::TileData& dpiece(int index) const; - ::dapi::data::TileData* add_dpiece(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& dpiece() const; - // repeated .dapi.data.PlayerData playerData = 16; - int playerdata_size() const; - private: - int _internal_playerdata_size() const; - - public: - void clear_playerdata() ; - ::dapi::data::PlayerData* mutable_playerdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* mutable_playerdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& _internal_playerdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* _internal_mutable_playerdata(); - public: - const ::dapi::data::PlayerData& playerdata(int index) const; - ::dapi::data::PlayerData* add_playerdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& playerdata() const; - // repeated .dapi.data.ItemData itemData = 17; - int itemdata_size() const; - private: - int _internal_itemdata_size() const; - - public: - void clear_itemdata() ; - ::dapi::data::ItemData* mutable_itemdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* mutable_itemdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& _internal_itemdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* _internal_mutable_itemdata(); - public: - const ::dapi::data::ItemData& itemdata(int index) const; - ::dapi::data::ItemData* add_itemdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& itemdata() const; - // repeated uint32 groundItemID = 18; - int grounditemid_size() const; - private: - int _internal_grounditemid_size() const; - - public: - void clear_grounditemid() ; - ::uint32_t grounditemid(int index) const; - void set_grounditemid(int index, ::uint32_t value); - void add_grounditemid(::uint32_t value); - const ::google::protobuf::RepeatedField<::uint32_t>& grounditemid() const; - ::google::protobuf::RepeatedField<::uint32_t>* mutable_grounditemid(); - - private: - const ::google::protobuf::RepeatedField<::uint32_t>& _internal_grounditemid() const; - ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_grounditemid(); - - public: - // repeated .dapi.data.TownerData townerData = 19; - int townerdata_size() const; - private: - int _internal_townerdata_size() const; - - public: - void clear_townerdata() ; - ::dapi::data::TownerData* mutable_townerdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* mutable_townerdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& _internal_townerdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* _internal_mutable_townerdata(); - public: - const ::dapi::data::TownerData& townerdata(int index) const; - ::dapi::data::TownerData* add_townerdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& townerdata() const; - // repeated uint32 storeOption = 20; - int storeoption_size() const; - private: - int _internal_storeoption_size() const; - - public: - void clear_storeoption() ; - ::uint32_t storeoption(int index) const; - void set_storeoption(int index, ::uint32_t value); - void add_storeoption(::uint32_t value); - const ::google::protobuf::RepeatedField<::uint32_t>& storeoption() const; - ::google::protobuf::RepeatedField<::uint32_t>* mutable_storeoption(); - - private: - const ::google::protobuf::RepeatedField<::uint32_t>& _internal_storeoption() const; - ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_storeoption(); - - public: - // repeated uint32 storeItems = 21; - int storeitems_size() const; - private: - int _internal_storeitems_size() const; - - public: - void clear_storeitems() ; - ::uint32_t storeitems(int index) const; - void set_storeitems(int index, ::uint32_t value); - void add_storeitems(::uint32_t value); - const ::google::protobuf::RepeatedField<::uint32_t>& storeitems() const; - ::google::protobuf::RepeatedField<::uint32_t>* mutable_storeitems(); - - private: - const ::google::protobuf::RepeatedField<::uint32_t>& _internal_storeitems() const; - ::google::protobuf::RepeatedField<::uint32_t>* _internal_mutable_storeitems(); - - public: - // repeated .dapi.data.TriggerData triggerData = 22; - int triggerdata_size() const; - private: - int _internal_triggerdata_size() const; - - public: - void clear_triggerdata() ; - ::dapi::data::TriggerData* mutable_triggerdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* mutable_triggerdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& _internal_triggerdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* _internal_mutable_triggerdata(); - public: - const ::dapi::data::TriggerData& triggerdata(int index) const; - ::dapi::data::TriggerData* add_triggerdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& triggerdata() const; - // repeated .dapi.data.MonsterData monsterData = 23; - int monsterdata_size() const; - private: - int _internal_monsterdata_size() const; - - public: - void clear_monsterdata() ; - ::dapi::data::MonsterData* mutable_monsterdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* mutable_monsterdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& _internal_monsterdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* _internal_mutable_monsterdata(); - public: - const ::dapi::data::MonsterData& monsterdata(int index) const; - ::dapi::data::MonsterData* add_monsterdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& monsterdata() const; - // repeated .dapi.data.ObjectData objectData = 24; - int objectdata_size() const; - private: - int _internal_objectdata_size() const; - - public: - void clear_objectdata() ; - ::dapi::data::ObjectData* mutable_objectdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* mutable_objectdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& _internal_objectdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* _internal_mutable_objectdata(); - public: - const ::dapi::data::ObjectData& objectdata(int index) const; - ::dapi::data::ObjectData* add_objectdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& objectdata() const; - // repeated .dapi.data.MissileData missileData = 25; - int missiledata_size() const; - private: - int _internal_missiledata_size() const; - - public: - void clear_missiledata() ; - ::dapi::data::MissileData* mutable_missiledata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* mutable_missiledata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& _internal_missiledata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* _internal_mutable_missiledata(); - public: - const ::dapi::data::MissileData& missiledata(int index) const; - ::dapi::data::MissileData* add_missiledata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& missiledata() const; - // repeated .dapi.data.PortalData portalData = 26; - int portaldata_size() const; - private: - int _internal_portaldata_size() const; - - public: - void clear_portaldata() ; - ::dapi::data::PortalData* mutable_portaldata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* mutable_portaldata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& _internal_portaldata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* _internal_mutable_portaldata(); - public: - const ::dapi::data::PortalData& portaldata(int index) const; - ::dapi::data::PortalData* add_portaldata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& portaldata() const; - // repeated .dapi.data.QuestData questData = 27; - int questdata_size() const; - private: - int _internal_questdata_size() const; - - public: - void clear_questdata() ; - ::dapi::data::QuestData* mutable_questdata(int index); - ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* mutable_questdata(); - - private: - const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& _internal_questdata() const; - ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* _internal_mutable_questdata(); - public: - const ::dapi::data::QuestData& questdata(int index) const; - ::dapi::data::QuestData* add_questdata(); - const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& questdata() const; - // string qtext = 9; - void clear_qtext() ; - const std::string& qtext() const; - template - void set_qtext(Arg_&& arg, Args_... args); - std::string* mutable_qtext(); - PROTOBUF_NODISCARD std::string* release_qtext(); - void set_allocated_qtext(std::string* value); - - private: - const std::string& _internal_qtext() const; - inline PROTOBUF_ALWAYS_INLINE void _internal_set_qtext( - const std::string& value); - std::string* _internal_mutable_qtext(); - - public: - // uint32 player = 1; - void clear_player() ; - ::uint32_t player() const; - void set_player(::uint32_t value); - - private: - ::uint32_t _internal_player() const; - void _internal_set_player(::uint32_t value); - - public: - // sint32 stextflag = 2; - void clear_stextflag() ; - ::int32_t stextflag() const; - void set_stextflag(::int32_t value); - - private: - ::int32_t _internal_stextflag() const; - void _internal_set_stextflag(::int32_t value); - - public: - // sint32 pauseMode = 3; - void clear_pausemode() ; - ::int32_t pausemode() const; - void set_pausemode(::int32_t value); - - private: - ::int32_t _internal_pausemode() const; - void _internal_set_pausemode(::int32_t value); - - public: - // uint32 cursor = 5; - void clear_cursor() ; - ::uint32_t cursor() const; - void set_cursor(::uint32_t value); - - private: - ::uint32_t _internal_cursor() const; - void _internal_set_cursor(::uint32_t value); - - public: - // bool menuOpen = 4; - void clear_menuopen() ; - bool menuopen() const; - void set_menuopen(bool value); - - private: - bool _internal_menuopen() const; - void _internal_set_menuopen(bool value); - - public: - // bool chrflag = 6; - void clear_chrflag() ; - bool chrflag() const; - void set_chrflag(bool value); - - private: - bool _internal_chrflag() const; - void _internal_set_chrflag(bool value); - - public: - // bool invflag = 7; - void clear_invflag() ; - bool invflag() const; - void set_invflag(bool value); - - private: - bool _internal_invflag() const; - void _internal_set_invflag(bool value); - - public: - // bool qtextflag = 8; - void clear_qtextflag() ; - bool qtextflag() const; - void set_qtextflag(bool value); - - private: - bool _internal_qtextflag() const; - void _internal_set_qtextflag(bool value); - - public: - // uint32 currlevel = 10; - void clear_currlevel() ; - ::uint32_t currlevel() const; - void set_currlevel(::uint32_t value); - - private: - ::uint32_t _internal_currlevel() const; - void _internal_set_currlevel(::uint32_t value); - - public: - // bool setlevel = 11; - void clear_setlevel() ; - bool setlevel() const; - void set_setlevel(bool value); - - private: - bool _internal_setlevel() const; - void _internal_set_setlevel(bool value); - - public: - // uint32 fps = 12; - void clear_fps() ; - ::uint32_t fps() const; - void set_fps(::uint32_t value); - - private: - ::uint32_t _internal_fps() const; - void _internal_set_fps(::uint32_t value); - - public: - // uint32 gameMode = 13; - void clear_gamemode() ; - ::uint32_t gamemode() const; - void set_gamemode(::uint32_t value); - - private: - ::uint32_t _internal_gamemode() const; - void _internal_set_gamemode(::uint32_t value); - - public: - // uint32 gnDifficulty = 14; - void clear_gndifficulty() ; - ::uint32_t gndifficulty() const; - void set_gndifficulty(::uint32_t value); - - private: - ::uint32_t _internal_gndifficulty() const; - void _internal_set_gndifficulty(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.game.FrameUpdate) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 5, 27, 10, - 59, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const FrameUpdate& from_msg); - ::google::protobuf::RepeatedPtrField< ::dapi::data::TileData > dpiece_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::PlayerData > playerdata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::ItemData > itemdata_; - ::google::protobuf::RepeatedField<::uint32_t> grounditemid_; - ::google::protobuf::internal::CachedSize _grounditemid_cached_byte_size_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::TownerData > townerdata_; - ::google::protobuf::RepeatedField<::uint32_t> storeoption_; - ::google::protobuf::internal::CachedSize _storeoption_cached_byte_size_; - ::google::protobuf::RepeatedField<::uint32_t> storeitems_; - ::google::protobuf::internal::CachedSize _storeitems_cached_byte_size_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::TriggerData > triggerdata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::MonsterData > monsterdata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::ObjectData > objectdata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::MissileData > missiledata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::PortalData > portaldata_; - ::google::protobuf::RepeatedPtrField< ::dapi::data::QuestData > questdata_; - ::google::protobuf::internal::ArenaStringPtr qtext_; - ::uint32_t player_; - ::int32_t stextflag_; - ::int32_t pausemode_; - ::uint32_t cursor_; - bool menuopen_; - bool chrflag_; - bool invflag_; - bool qtextflag_; - ::uint32_t currlevel_; - bool setlevel_; - ::uint32_t fps_; - ::uint32_t gamemode_; - ::uint32_t gndifficulty_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_game_2eproto; -}; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// FrameUpdate - -// uint32 player = 1; -inline void FrameUpdate::clear_player() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_ = 0u; -} -inline ::uint32_t FrameUpdate::player() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.player) - return _internal_player(); -} -inline void FrameUpdate::set_player(::uint32_t value) { - _internal_set_player(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.player) -} -inline ::uint32_t FrameUpdate::_internal_player() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.player_; -} -inline void FrameUpdate::_internal_set_player(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.player_ = value; -} - -// sint32 stextflag = 2; -inline void FrameUpdate::clear_stextflag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stextflag_ = 0; -} -inline ::int32_t FrameUpdate::stextflag() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.stextflag) - return _internal_stextflag(); -} -inline void FrameUpdate::set_stextflag(::int32_t value) { - _internal_set_stextflag(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.stextflag) -} -inline ::int32_t FrameUpdate::_internal_stextflag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.stextflag_; -} -inline void FrameUpdate::_internal_set_stextflag(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.stextflag_ = value; -} - -// sint32 pauseMode = 3; -inline void FrameUpdate::clear_pausemode() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pausemode_ = 0; -} -inline ::int32_t FrameUpdate::pausemode() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.pauseMode) - return _internal_pausemode(); -} -inline void FrameUpdate::set_pausemode(::int32_t value) { - _internal_set_pausemode(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.pauseMode) -} -inline ::int32_t FrameUpdate::_internal_pausemode() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.pausemode_; -} -inline void FrameUpdate::_internal_set_pausemode(::int32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.pausemode_ = value; -} - -// bool menuOpen = 4; -inline void FrameUpdate::clear_menuopen() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.menuopen_ = false; -} -inline bool FrameUpdate::menuopen() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.menuOpen) - return _internal_menuopen(); -} -inline void FrameUpdate::set_menuopen(bool value) { - _internal_set_menuopen(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.menuOpen) -} -inline bool FrameUpdate::_internal_menuopen() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.menuopen_; -} -inline void FrameUpdate::_internal_set_menuopen(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.menuopen_ = value; -} - -// uint32 cursor = 5; -inline void FrameUpdate::clear_cursor() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.cursor_ = 0u; -} -inline ::uint32_t FrameUpdate::cursor() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.cursor) - return _internal_cursor(); -} -inline void FrameUpdate::set_cursor(::uint32_t value) { - _internal_set_cursor(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.cursor) -} -inline ::uint32_t FrameUpdate::_internal_cursor() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.cursor_; -} -inline void FrameUpdate::_internal_set_cursor(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.cursor_ = value; -} - -// bool chrflag = 6; -inline void FrameUpdate::clear_chrflag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.chrflag_ = false; -} -inline bool FrameUpdate::chrflag() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.chrflag) - return _internal_chrflag(); -} -inline void FrameUpdate::set_chrflag(bool value) { - _internal_set_chrflag(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.chrflag) -} -inline bool FrameUpdate::_internal_chrflag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.chrflag_; -} -inline void FrameUpdate::_internal_set_chrflag(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.chrflag_ = value; -} - -// bool invflag = 7; -inline void FrameUpdate::clear_invflag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.invflag_ = false; -} -inline bool FrameUpdate::invflag() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.invflag) - return _internal_invflag(); -} -inline void FrameUpdate::set_invflag(bool value) { - _internal_set_invflag(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.invflag) -} -inline bool FrameUpdate::_internal_invflag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.invflag_; -} -inline void FrameUpdate::_internal_set_invflag(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.invflag_ = value; -} - -// bool qtextflag = 8; -inline void FrameUpdate::clear_qtextflag() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtextflag_ = false; -} -inline bool FrameUpdate::qtextflag() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.qtextflag) - return _internal_qtextflag(); -} -inline void FrameUpdate::set_qtextflag(bool value) { - _internal_set_qtextflag(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.qtextflag) -} -inline bool FrameUpdate::_internal_qtextflag() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.qtextflag_; -} -inline void FrameUpdate::_internal_set_qtextflag(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtextflag_ = value; -} - -// string qtext = 9; -inline void FrameUpdate::clear_qtext() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtext_.ClearToEmpty(); -} -inline const std::string& FrameUpdate::qtext() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.qtext) - return _internal_qtext(); -} -template -inline PROTOBUF_ALWAYS_INLINE void FrameUpdate::set_qtext(Arg_&& arg, - Args_... args) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtext_.Set(static_cast(arg), args..., GetArena()); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.qtext) -} -inline std::string* FrameUpdate::mutable_qtext() ABSL_ATTRIBUTE_LIFETIME_BOUND { - std::string* _s = _internal_mutable_qtext(); - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.qtext) - return _s; -} -inline const std::string& FrameUpdate::_internal_qtext() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.qtext_.Get(); -} -inline void FrameUpdate::_internal_set_qtext(const std::string& value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtext_.Set(value, GetArena()); -} -inline std::string* FrameUpdate::_internal_mutable_qtext() { - ::google::protobuf::internal::TSanWrite(&_impl_); - return _impl_.qtext_.Mutable( GetArena()); -} -inline std::string* FrameUpdate::release_qtext() { - ::google::protobuf::internal::TSanWrite(&_impl_); - // @@protoc_insertion_point(field_release:dapi.game.FrameUpdate.qtext) - return _impl_.qtext_.Release(); -} -inline void FrameUpdate::set_allocated_qtext(std::string* value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.qtext_.SetAllocated(value, GetArena()); - if (::google::protobuf::internal::DebugHardenForceCopyDefaultString() && _impl_.qtext_.IsDefault()) { - _impl_.qtext_.Set("", GetArena()); - } - // @@protoc_insertion_point(field_set_allocated:dapi.game.FrameUpdate.qtext) -} - -// uint32 currlevel = 10; -inline void FrameUpdate::clear_currlevel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.currlevel_ = 0u; -} -inline ::uint32_t FrameUpdate::currlevel() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.currlevel) - return _internal_currlevel(); -} -inline void FrameUpdate::set_currlevel(::uint32_t value) { - _internal_set_currlevel(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.currlevel) -} -inline ::uint32_t FrameUpdate::_internal_currlevel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.currlevel_; -} -inline void FrameUpdate::_internal_set_currlevel(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.currlevel_ = value; -} - -// bool setlevel = 11; -inline void FrameUpdate::clear_setlevel() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.setlevel_ = false; -} -inline bool FrameUpdate::setlevel() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.setlevel) - return _internal_setlevel(); -} -inline void FrameUpdate::set_setlevel(bool value) { - _internal_set_setlevel(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.setlevel) -} -inline bool FrameUpdate::_internal_setlevel() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.setlevel_; -} -inline void FrameUpdate::_internal_set_setlevel(bool value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.setlevel_ = value; -} - -// uint32 fps = 12; -inline void FrameUpdate::clear_fps() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fps_ = 0u; -} -inline ::uint32_t FrameUpdate::fps() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.fps) - return _internal_fps(); -} -inline void FrameUpdate::set_fps(::uint32_t value) { - _internal_set_fps(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.fps) -} -inline ::uint32_t FrameUpdate::_internal_fps() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.fps_; -} -inline void FrameUpdate::_internal_set_fps(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.fps_ = value; -} - -// uint32 gameMode = 13; -inline void FrameUpdate::clear_gamemode() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.gamemode_ = 0u; -} -inline ::uint32_t FrameUpdate::gamemode() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.gameMode) - return _internal_gamemode(); -} -inline void FrameUpdate::set_gamemode(::uint32_t value) { - _internal_set_gamemode(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.gameMode) -} -inline ::uint32_t FrameUpdate::_internal_gamemode() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.gamemode_; -} -inline void FrameUpdate::_internal_set_gamemode(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.gamemode_ = value; -} - -// uint32 gnDifficulty = 14; -inline void FrameUpdate::clear_gndifficulty() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.gndifficulty_ = 0u; -} -inline ::uint32_t FrameUpdate::gndifficulty() const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.gnDifficulty) - return _internal_gndifficulty(); -} -inline void FrameUpdate::set_gndifficulty(::uint32_t value) { - _internal_set_gndifficulty(value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.gnDifficulty) -} -inline ::uint32_t FrameUpdate::_internal_gndifficulty() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.gndifficulty_; -} -inline void FrameUpdate::_internal_set_gndifficulty(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.gndifficulty_ = value; -} - -// repeated .dapi.data.TileData dPiece = 15; -inline int FrameUpdate::_internal_dpiece_size() const { - return _internal_dpiece().size(); -} -inline int FrameUpdate::dpiece_size() const { - return _internal_dpiece_size(); -} -inline ::dapi::data::TileData* FrameUpdate::mutable_dpiece(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.dPiece) - return _internal_mutable_dpiece()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* FrameUpdate::mutable_dpiece() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.dPiece) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_dpiece(); -} -inline const ::dapi::data::TileData& FrameUpdate::dpiece(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.dPiece) - return _internal_dpiece().Get(index); -} -inline ::dapi::data::TileData* FrameUpdate::add_dpiece() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::TileData* _add = _internal_mutable_dpiece()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.dPiece) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& FrameUpdate::dpiece() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.dPiece) - return _internal_dpiece(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>& -FrameUpdate::_internal_dpiece() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.dpiece_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TileData>* -FrameUpdate::_internal_mutable_dpiece() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.dpiece_; -} - -// repeated .dapi.data.PlayerData playerData = 16; -inline int FrameUpdate::_internal_playerdata_size() const { - return _internal_playerdata().size(); -} -inline int FrameUpdate::playerdata_size() const { - return _internal_playerdata_size(); -} -inline ::dapi::data::PlayerData* FrameUpdate::mutable_playerdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.playerData) - return _internal_mutable_playerdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* FrameUpdate::mutable_playerdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.playerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_playerdata(); -} -inline const ::dapi::data::PlayerData& FrameUpdate::playerdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.playerData) - return _internal_playerdata().Get(index); -} -inline ::dapi::data::PlayerData* FrameUpdate::add_playerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::PlayerData* _add = _internal_mutable_playerdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.playerData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& FrameUpdate::playerdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.playerData) - return _internal_playerdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>& -FrameUpdate::_internal_playerdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.playerdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::PlayerData>* -FrameUpdate::_internal_mutable_playerdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.playerdata_; -} - -// repeated .dapi.data.ItemData itemData = 17; -inline int FrameUpdate::_internal_itemdata_size() const { - return _internal_itemdata().size(); -} -inline int FrameUpdate::itemdata_size() const { - return _internal_itemdata_size(); -} -inline ::dapi::data::ItemData* FrameUpdate::mutable_itemdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.itemData) - return _internal_mutable_itemdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* FrameUpdate::mutable_itemdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.itemData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_itemdata(); -} -inline const ::dapi::data::ItemData& FrameUpdate::itemdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.itemData) - return _internal_itemdata().Get(index); -} -inline ::dapi::data::ItemData* FrameUpdate::add_itemdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::ItemData* _add = _internal_mutable_itemdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.itemData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& FrameUpdate::itemdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.itemData) - return _internal_itemdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>& -FrameUpdate::_internal_itemdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.itemdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::ItemData>* -FrameUpdate::_internal_mutable_itemdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.itemdata_; -} - -// repeated uint32 groundItemID = 18; -inline int FrameUpdate::_internal_grounditemid_size() const { - return _internal_grounditemid().size(); -} -inline int FrameUpdate::grounditemid_size() const { - return _internal_grounditemid_size(); -} -inline void FrameUpdate::clear_grounditemid() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.grounditemid_.Clear(); -} -inline ::uint32_t FrameUpdate::grounditemid(int index) const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.groundItemID) - return _internal_grounditemid().Get(index); -} -inline void FrameUpdate::set_grounditemid(int index, ::uint32_t value) { - _internal_mutable_grounditemid()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.groundItemID) -} -inline void FrameUpdate::add_grounditemid(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_grounditemid()->Add(value); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.groundItemID) -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::grounditemid() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.groundItemID) - return _internal_grounditemid(); -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_grounditemid() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.groundItemID) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_grounditemid(); -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& -FrameUpdate::_internal_grounditemid() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.grounditemid_; -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_grounditemid() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.grounditemid_; -} - -// repeated .dapi.data.TownerData townerData = 19; -inline int FrameUpdate::_internal_townerdata_size() const { - return _internal_townerdata().size(); -} -inline int FrameUpdate::townerdata_size() const { - return _internal_townerdata_size(); -} -inline ::dapi::data::TownerData* FrameUpdate::mutable_townerdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.townerData) - return _internal_mutable_townerdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* FrameUpdate::mutable_townerdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.townerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_townerdata(); -} -inline const ::dapi::data::TownerData& FrameUpdate::townerdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.townerData) - return _internal_townerdata().Get(index); -} -inline ::dapi::data::TownerData* FrameUpdate::add_townerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::TownerData* _add = _internal_mutable_townerdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.townerData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& FrameUpdate::townerdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.townerData) - return _internal_townerdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>& -FrameUpdate::_internal_townerdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.townerdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TownerData>* -FrameUpdate::_internal_mutable_townerdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.townerdata_; -} - -// repeated uint32 storeOption = 20; -inline int FrameUpdate::_internal_storeoption_size() const { - return _internal_storeoption().size(); -} -inline int FrameUpdate::storeoption_size() const { - return _internal_storeoption_size(); -} -inline void FrameUpdate::clear_storeoption() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.storeoption_.Clear(); -} -inline ::uint32_t FrameUpdate::storeoption(int index) const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.storeOption) - return _internal_storeoption().Get(index); -} -inline void FrameUpdate::set_storeoption(int index, ::uint32_t value) { - _internal_mutable_storeoption()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.storeOption) -} -inline void FrameUpdate::add_storeoption(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_storeoption()->Add(value); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.storeOption) -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::storeoption() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.storeOption) - return _internal_storeoption(); -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_storeoption() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.storeOption) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_storeoption(); -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& -FrameUpdate::_internal_storeoption() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.storeoption_; -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_storeoption() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.storeoption_; -} - -// repeated uint32 storeItems = 21; -inline int FrameUpdate::_internal_storeitems_size() const { - return _internal_storeitems().size(); -} -inline int FrameUpdate::storeitems_size() const { - return _internal_storeitems_size(); -} -inline void FrameUpdate::clear_storeitems() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.storeitems_.Clear(); -} -inline ::uint32_t FrameUpdate::storeitems(int index) const { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.storeItems) - return _internal_storeitems().Get(index); -} -inline void FrameUpdate::set_storeitems(int index, ::uint32_t value) { - _internal_mutable_storeitems()->Set(index, value); - // @@protoc_insertion_point(field_set:dapi.game.FrameUpdate.storeItems) -} -inline void FrameUpdate::add_storeitems(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _internal_mutable_storeitems()->Add(value); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.storeItems) -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& FrameUpdate::storeitems() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.storeItems) - return _internal_storeitems(); -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::mutable_storeitems() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.storeItems) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_storeitems(); -} -inline const ::google::protobuf::RepeatedField<::uint32_t>& -FrameUpdate::_internal_storeitems() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.storeitems_; -} -inline ::google::protobuf::RepeatedField<::uint32_t>* FrameUpdate::_internal_mutable_storeitems() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.storeitems_; -} - -// repeated .dapi.data.TriggerData triggerData = 22; -inline int FrameUpdate::_internal_triggerdata_size() const { - return _internal_triggerdata().size(); -} -inline int FrameUpdate::triggerdata_size() const { - return _internal_triggerdata_size(); -} -inline ::dapi::data::TriggerData* FrameUpdate::mutable_triggerdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.triggerData) - return _internal_mutable_triggerdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* FrameUpdate::mutable_triggerdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.triggerData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_triggerdata(); -} -inline const ::dapi::data::TriggerData& FrameUpdate::triggerdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.triggerData) - return _internal_triggerdata().Get(index); -} -inline ::dapi::data::TriggerData* FrameUpdate::add_triggerdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::TriggerData* _add = _internal_mutable_triggerdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.triggerData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& FrameUpdate::triggerdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.triggerData) - return _internal_triggerdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>& -FrameUpdate::_internal_triggerdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.triggerdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::TriggerData>* -FrameUpdate::_internal_mutable_triggerdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.triggerdata_; -} - -// repeated .dapi.data.MonsterData monsterData = 23; -inline int FrameUpdate::_internal_monsterdata_size() const { - return _internal_monsterdata().size(); -} -inline int FrameUpdate::monsterdata_size() const { - return _internal_monsterdata_size(); -} -inline ::dapi::data::MonsterData* FrameUpdate::mutable_monsterdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.monsterData) - return _internal_mutable_monsterdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* FrameUpdate::mutable_monsterdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.monsterData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_monsterdata(); -} -inline const ::dapi::data::MonsterData& FrameUpdate::monsterdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.monsterData) - return _internal_monsterdata().Get(index); -} -inline ::dapi::data::MonsterData* FrameUpdate::add_monsterdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::MonsterData* _add = _internal_mutable_monsterdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.monsterData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& FrameUpdate::monsterdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.monsterData) - return _internal_monsterdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>& -FrameUpdate::_internal_monsterdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.monsterdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::MonsterData>* -FrameUpdate::_internal_mutable_monsterdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.monsterdata_; -} - -// repeated .dapi.data.ObjectData objectData = 24; -inline int FrameUpdate::_internal_objectdata_size() const { - return _internal_objectdata().size(); -} -inline int FrameUpdate::objectdata_size() const { - return _internal_objectdata_size(); -} -inline ::dapi::data::ObjectData* FrameUpdate::mutable_objectdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.objectData) - return _internal_mutable_objectdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* FrameUpdate::mutable_objectdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.objectData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_objectdata(); -} -inline const ::dapi::data::ObjectData& FrameUpdate::objectdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.objectData) - return _internal_objectdata().Get(index); -} -inline ::dapi::data::ObjectData* FrameUpdate::add_objectdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::ObjectData* _add = _internal_mutable_objectdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.objectData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& FrameUpdate::objectdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.objectData) - return _internal_objectdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>& -FrameUpdate::_internal_objectdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.objectdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::ObjectData>* -FrameUpdate::_internal_mutable_objectdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.objectdata_; -} - -// repeated .dapi.data.MissileData missileData = 25; -inline int FrameUpdate::_internal_missiledata_size() const { - return _internal_missiledata().size(); -} -inline int FrameUpdate::missiledata_size() const { - return _internal_missiledata_size(); -} -inline ::dapi::data::MissileData* FrameUpdate::mutable_missiledata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.missileData) - return _internal_mutable_missiledata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* FrameUpdate::mutable_missiledata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.missileData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_missiledata(); -} -inline const ::dapi::data::MissileData& FrameUpdate::missiledata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.missileData) - return _internal_missiledata().Get(index); -} -inline ::dapi::data::MissileData* FrameUpdate::add_missiledata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::MissileData* _add = _internal_mutable_missiledata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.missileData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& FrameUpdate::missiledata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.missileData) - return _internal_missiledata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>& -FrameUpdate::_internal_missiledata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.missiledata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::MissileData>* -FrameUpdate::_internal_mutable_missiledata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.missiledata_; -} - -// repeated .dapi.data.PortalData portalData = 26; -inline int FrameUpdate::_internal_portaldata_size() const { - return _internal_portaldata().size(); -} -inline int FrameUpdate::portaldata_size() const { - return _internal_portaldata_size(); -} -inline ::dapi::data::PortalData* FrameUpdate::mutable_portaldata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.portalData) - return _internal_mutable_portaldata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* FrameUpdate::mutable_portaldata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.portalData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_portaldata(); -} -inline const ::dapi::data::PortalData& FrameUpdate::portaldata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.portalData) - return _internal_portaldata().Get(index); -} -inline ::dapi::data::PortalData* FrameUpdate::add_portaldata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::PortalData* _add = _internal_mutable_portaldata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.portalData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& FrameUpdate::portaldata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.portalData) - return _internal_portaldata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>& -FrameUpdate::_internal_portaldata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.portaldata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::PortalData>* -FrameUpdate::_internal_mutable_portaldata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.portaldata_; -} - -// repeated .dapi.data.QuestData questData = 27; -inline int FrameUpdate::_internal_questdata_size() const { - return _internal_questdata().size(); -} -inline int FrameUpdate::questdata_size() const { - return _internal_questdata_size(); -} -inline ::dapi::data::QuestData* FrameUpdate::mutable_questdata(int index) - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable:dapi.game.FrameUpdate.questData) - return _internal_mutable_questdata()->Mutable(index); -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* FrameUpdate::mutable_questdata() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_mutable_list:dapi.game.FrameUpdate.questData) - ::google::protobuf::internal::TSanWrite(&_impl_); - return _internal_mutable_questdata(); -} -inline const ::dapi::data::QuestData& FrameUpdate::questdata(int index) const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.game.FrameUpdate.questData) - return _internal_questdata().Get(index); -} -inline ::dapi::data::QuestData* FrameUpdate::add_questdata() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::google::protobuf::internal::TSanWrite(&_impl_); - ::dapi::data::QuestData* _add = _internal_mutable_questdata()->Add(); - // @@protoc_insertion_point(field_add:dapi.game.FrameUpdate.questData) - return _add; -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& FrameUpdate::questdata() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_list:dapi.game.FrameUpdate.questData) - return _internal_questdata(); -} -inline const ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>& -FrameUpdate::_internal_questdata() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.questdata_; -} -inline ::google::protobuf::RepeatedPtrField<::dapi::data::QuestData>* -FrameUpdate::_internal_mutable_questdata() { - ::google::protobuf::internal::TSanRead(&_impl_); - return &_impl_.questdata_; -} - -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ - -// @@protoc_insertion_point(namespace_scope) -} // namespace game -} // namespace dapi - - -// @@protoc_insertion_point(global_scope) - -#include "google/protobuf/port_undef.inc" - -#endif // game_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/init.pb.cc b/Source/dapi/Backend/Messages/generated/init.pb.cc deleted file mode 100644 index 65ad5687d..000000000 --- a/Source/dapi/Backend/Messages/generated/init.pb.cc +++ /dev/null @@ -1,467 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: init.proto -// Protobuf C++ Version: 5.29.3 - -#include "init.pb.h" - -#include -#include -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/generated_message_tctable_impl.h" -#include "google/protobuf/extension_set.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/wire_format_lite.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" -PROTOBUF_PRAGMA_INIT_SEG -namespace _pb = ::google::protobuf; -namespace _pbi = ::google::protobuf::internal; -namespace _fl = ::google::protobuf::internal::field_layout; -namespace dapi { -namespace init { - -inline constexpr ServerResponse::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : port_{0u}, - _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ServerResponse::ServerResponse(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ServerResponseDefaultTypeInternal { - PROTOBUF_CONSTEXPR ServerResponseDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ServerResponseDefaultTypeInternal() {} - union { - ServerResponse _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ServerResponseDefaultTypeInternal _ServerResponse_default_instance_; - -inline constexpr ClientBroadcast::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR ClientBroadcast::ClientBroadcast(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct ClientBroadcastDefaultTypeInternal { - PROTOBUF_CONSTEXPR ClientBroadcastDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~ClientBroadcastDefaultTypeInternal() {} - union { - ClientBroadcast _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 ClientBroadcastDefaultTypeInternal _ClientBroadcast_default_instance_; -} // namespace init -} // namespace dapi -namespace dapi { -namespace init { -// =================================================================== - -class ClientBroadcast::_Internal { - public: -}; - -ClientBroadcast::ClientBroadcast(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.init.ClientBroadcast) -} -ClientBroadcast::ClientBroadcast( - ::google::protobuf::Arena* arena, const ClientBroadcast& from) - : ClientBroadcast(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ClientBroadcast::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ClientBroadcast::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -ClientBroadcast::~ClientBroadcast() { - // @@protoc_insertion_point(destructor:dapi.init.ClientBroadcast) - SharedDtor(*this); -} -inline void ClientBroadcast::SharedDtor(MessageLite& self) { - ClientBroadcast& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ClientBroadcast::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ClientBroadcast(arena); -} -constexpr auto ClientBroadcast::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ClientBroadcast), - alignof(ClientBroadcast)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<26> ClientBroadcast::_class_data_ = { - { - &_ClientBroadcast_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ClientBroadcast::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ClientBroadcast::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ClientBroadcast::ByteSizeLong, - &ClientBroadcast::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ClientBroadcast, _impl_._cached_size_), - true, - }, - "dapi.init.ClientBroadcast", -}; -const ::google::protobuf::internal::ClassData* ClientBroadcast::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> ClientBroadcast::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::init::ClientBroadcast>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ClientBroadcast::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.init.ClientBroadcast) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ClientBroadcast::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ClientBroadcast& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ClientBroadcast::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ClientBroadcast& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.init.ClientBroadcast) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.init.ClientBroadcast) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ClientBroadcast::ByteSizeLong(const MessageLite& base) { - const ClientBroadcast& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ClientBroadcast::ByteSizeLong() const { - const ClientBroadcast& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.init.ClientBroadcast) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ClientBroadcast::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.init.ClientBroadcast) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ClientBroadcast::CopyFrom(const ClientBroadcast& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.init.ClientBroadcast) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ClientBroadcast::InternalSwap(ClientBroadcast* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class ServerResponse::_Internal { - public: -}; - -ServerResponse::ServerResponse(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.init.ServerResponse) -} -ServerResponse::ServerResponse( - ::google::protobuf::Arena* arena, const ServerResponse& from) - : ServerResponse(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE ServerResponse::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void ServerResponse::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); - _impl_.port_ = {}; -} -ServerResponse::~ServerResponse() { - // @@protoc_insertion_point(destructor:dapi.init.ServerResponse) - SharedDtor(*this); -} -inline void ServerResponse::SharedDtor(MessageLite& self) { - ServerResponse& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* ServerResponse::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) ServerResponse(arena); -} -constexpr auto ServerResponse::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(ServerResponse), - alignof(ServerResponse)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<25> ServerResponse::_class_data_ = { - { - &_ServerResponse_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &ServerResponse::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &ServerResponse::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &ServerResponse::ByteSizeLong, - &ServerResponse::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_._cached_size_), - true, - }, - "dapi.init.ServerResponse", -}; -const ::google::protobuf::internal::ClassData* ServerResponse::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 1, 0, 0, 2> ServerResponse::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 1, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967294, // skipmap - offsetof(decltype(_table_), field_entries), - 1, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::init::ServerResponse>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - // uint32 port = 1; - {::_pbi::TcParser::FastV32S1, - {8, 63, 0, PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_.port_)}}, - }}, {{ - 65535, 65535 - }}, {{ - // uint32 port = 1; - {PROTOBUF_FIELD_OFFSET(ServerResponse, _impl_.port_), 0, 0, - (0 | ::_fl::kFcSingular | ::_fl::kUInt32)}, - }}, - // no aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void ServerResponse::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.init.ServerResponse) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _impl_.port_ = 0u; - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* ServerResponse::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const ServerResponse& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* ServerResponse::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const ServerResponse& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.init.ServerResponse) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - // uint32 port = 1; - if (this_._internal_port() != 0) { - target = stream->EnsureSpace(target); - target = ::_pbi::WireFormatLite::WriteUInt32ToArray( - 1, this_._internal_port(), target); - } - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.init.ServerResponse) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t ServerResponse::ByteSizeLong(const MessageLite& base) { - const ServerResponse& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t ServerResponse::ByteSizeLong() const { - const ServerResponse& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.init.ServerResponse) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - { - // uint32 port = 1; - if (this_._internal_port() != 0) { - total_size += ::_pbi::WireFormatLite::UInt32SizePlusOne( - this_._internal_port()); - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void ServerResponse::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.init.ServerResponse) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (from._internal_port() != 0) { - _this->_impl_.port_ = from._impl_.port_; - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void ServerResponse::CopyFrom(const ServerResponse& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.init.ServerResponse) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void ServerResponse::InternalSwap(ServerResponse* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.port_, other->_impl_.port_); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace init -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google -// @@protoc_insertion_point(global_scope) -#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/init.pb.h b/Source/dapi/Backend/Messages/generated/init.pb.h deleted file mode 100644 index 2eb3fa885..000000000 --- a/Source/dapi/Backend/Messages/generated/init.pb.h +++ /dev/null @@ -1,466 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: init.proto -// Protobuf C++ Version: 5.29.3 - -#ifndef init_2eproto_2epb_2eh -#define init_2eproto_2epb_2eh - -#include -#include -#include -#include - -#include "google/protobuf/runtime_version.h" -#if PROTOBUF_VERSION != 5029003 -#error "Protobuf C++ gencode is built with an incompatible version of" -#error "Protobuf C++ headers/runtime. See" -#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" -#endif -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/arena.h" -#include "google/protobuf/arenastring.h" -#include "google/protobuf/generated_message_tctable_decl.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/metadata_lite.h" -#include "google/protobuf/message_lite.h" -#include "google/protobuf/repeated_field.h" // IWYU pragma: export -#include "google/protobuf/extension_set.h" // IWYU pragma: export -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" - -#define PROTOBUF_INTERNAL_EXPORT_init_2eproto - -namespace google { -namespace protobuf { -namespace internal { -template -::absl::string_view GetAnyMessageName(); -} // namespace internal -} // namespace protobuf -} // namespace google - -// Internal implementation detail -- do not use these members. -struct TableStruct_init_2eproto { - static const ::uint32_t offsets[]; -}; -namespace dapi { -namespace init { -class ClientBroadcast; -struct ClientBroadcastDefaultTypeInternal; -extern ClientBroadcastDefaultTypeInternal _ClientBroadcast_default_instance_; -class ServerResponse; -struct ServerResponseDefaultTypeInternal; -extern ServerResponseDefaultTypeInternal _ServerResponse_default_instance_; -} // namespace init -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google - -namespace dapi { -namespace init { - -// =================================================================== - - -// ------------------------------------------------------------------- - -class ServerResponse final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.init.ServerResponse) */ { - public: - inline ServerResponse() : ServerResponse(nullptr) {} - ~ServerResponse() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ServerResponse* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ServerResponse)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ServerResponse( - ::google::protobuf::internal::ConstantInitialized); - - inline ServerResponse(const ServerResponse& from) : ServerResponse(nullptr, from) {} - inline ServerResponse(ServerResponse&& from) noexcept - : ServerResponse(nullptr, std::move(from)) {} - inline ServerResponse& operator=(const ServerResponse& from) { - CopyFrom(from); - return *this; - } - inline ServerResponse& operator=(ServerResponse&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ServerResponse& default_instance() { - return *internal_default_instance(); - } - static inline const ServerResponse* internal_default_instance() { - return reinterpret_cast( - &_ServerResponse_default_instance_); - } - static constexpr int kIndexInFileMessages = 1; - friend void swap(ServerResponse& a, ServerResponse& b) { a.Swap(&b); } - inline void Swap(ServerResponse* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ServerResponse* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ServerResponse* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ServerResponse& from); - void MergeFrom(const ServerResponse& from) { ServerResponse::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ServerResponse* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.init.ServerResponse"; } - - protected: - explicit ServerResponse(::google::protobuf::Arena* arena); - ServerResponse(::google::protobuf::Arena* arena, const ServerResponse& from); - ServerResponse(::google::protobuf::Arena* arena, ServerResponse&& from) noexcept - : ServerResponse(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<25> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kPortFieldNumber = 1, - }; - // uint32 port = 1; - void clear_port() ; - ::uint32_t port() const; - void set_port(::uint32_t value); - - private: - ::uint32_t _internal_port() const; - void _internal_set_port(::uint32_t value); - - public: - // @@protoc_insertion_point(class_scope:dapi.init.ServerResponse) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 1, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ServerResponse& from_msg); - ::uint32_t port_; - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_init_2eproto; -}; -// ------------------------------------------------------------------- - -class ClientBroadcast final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.init.ClientBroadcast) */ { - public: - inline ClientBroadcast() : ClientBroadcast(nullptr) {} - ~ClientBroadcast() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(ClientBroadcast* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(ClientBroadcast)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR ClientBroadcast( - ::google::protobuf::internal::ConstantInitialized); - - inline ClientBroadcast(const ClientBroadcast& from) : ClientBroadcast(nullptr, from) {} - inline ClientBroadcast(ClientBroadcast&& from) noexcept - : ClientBroadcast(nullptr, std::move(from)) {} - inline ClientBroadcast& operator=(const ClientBroadcast& from) { - CopyFrom(from); - return *this; - } - inline ClientBroadcast& operator=(ClientBroadcast&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const ClientBroadcast& default_instance() { - return *internal_default_instance(); - } - static inline const ClientBroadcast* internal_default_instance() { - return reinterpret_cast( - &_ClientBroadcast_default_instance_); - } - static constexpr int kIndexInFileMessages = 0; - friend void swap(ClientBroadcast& a, ClientBroadcast& b) { a.Swap(&b); } - inline void Swap(ClientBroadcast* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(ClientBroadcast* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - ClientBroadcast* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const ClientBroadcast& from); - void MergeFrom(const ClientBroadcast& from) { ClientBroadcast::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(ClientBroadcast* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.init.ClientBroadcast"; } - - protected: - explicit ClientBroadcast(::google::protobuf::Arena* arena); - ClientBroadcast(::google::protobuf::Arena* arena, const ClientBroadcast& from); - ClientBroadcast(::google::protobuf::Arena* arena, ClientBroadcast&& from) noexcept - : ClientBroadcast(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<26> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.init.ClientBroadcast) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const ClientBroadcast& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_init_2eproto; -}; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ClientBroadcast - -// ------------------------------------------------------------------- - -// ServerResponse - -// uint32 port = 1; -inline void ServerResponse::clear_port() { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.port_ = 0u; -} -inline ::uint32_t ServerResponse::port() const { - // @@protoc_insertion_point(field_get:dapi.init.ServerResponse.port) - return _internal_port(); -} -inline void ServerResponse::set_port(::uint32_t value) { - _internal_set_port(value); - // @@protoc_insertion_point(field_set:dapi.init.ServerResponse.port) -} -inline ::uint32_t ServerResponse::_internal_port() const { - ::google::protobuf::internal::TSanRead(&_impl_); - return _impl_.port_; -} -inline void ServerResponse::_internal_set_port(::uint32_t value) { - ::google::protobuf::internal::TSanWrite(&_impl_); - _impl_.port_ = value; -} - -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ - -// @@protoc_insertion_point(namespace_scope) -} // namespace init -} // namespace dapi - - -// @@protoc_insertion_point(global_scope) - -#include "google/protobuf/port_undef.inc" - -#endif // init_2eproto_2epb_2eh diff --git a/Source/dapi/Backend/Messages/generated/message.pb.cc b/Source/dapi/Backend/Messages/generated/message.pb.cc deleted file mode 100644 index a9c8ad403..000000000 --- a/Source/dapi/Backend/Messages/generated/message.pb.cc +++ /dev/null @@ -1,818 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: message.proto -// Protobuf C++ Version: 5.29.3 - -#include "message.pb.h" - -#include -#include -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/generated_message_tctable_impl.h" -#include "google/protobuf/extension_set.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/wire_format_lite.h" -#include "google/protobuf/io/zero_copy_stream_impl_lite.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" -PROTOBUF_PRAGMA_INIT_SEG -namespace _pb = ::google::protobuf; -namespace _pbi = ::google::protobuf::internal; -namespace _fl = ::google::protobuf::internal::field_layout; -namespace dapi { -namespace message { - -inline constexpr EndofQueue::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : _cached_size_{0} {} - -template -PROTOBUF_CONSTEXPR EndofQueue::EndofQueue(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct EndofQueueDefaultTypeInternal { - PROTOBUF_CONSTEXPR EndofQueueDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~EndofQueueDefaultTypeInternal() {} - union { - EndofQueue _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 EndofQueueDefaultTypeInternal _EndofQueue_default_instance_; - -inline constexpr Message::Impl_::Impl_( - ::_pbi::ConstantInitialized) noexcept - : msg_{}, - _cached_size_{0}, - _oneof_case_{} {} - -template -PROTOBUF_CONSTEXPR Message::Message(::_pbi::ConstantInitialized) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(_class_data_.base()), -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(), -#endif // PROTOBUF_CUSTOM_VTABLE - _impl_(::_pbi::ConstantInitialized()) { -} -struct MessageDefaultTypeInternal { - PROTOBUF_CONSTEXPR MessageDefaultTypeInternal() : _instance(::_pbi::ConstantInitialized{}) {} - ~MessageDefaultTypeInternal() {} - union { - Message _instance; - }; -}; - -PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT - PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 MessageDefaultTypeInternal _Message_default_instance_; -} // namespace message -} // namespace dapi -namespace dapi { -namespace message { -// =================================================================== - -class EndofQueue::_Internal { - public: -}; - -EndofQueue::EndofQueue(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.message.EndofQueue) -} -EndofQueue::EndofQueue( - ::google::protobuf::Arena* arena, const EndofQueue& from) - : EndofQueue(arena) { - MergeFrom(from); -} -inline PROTOBUF_NDEBUG_INLINE EndofQueue::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : _cached_size_{0} {} - -inline void EndofQueue::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -EndofQueue::~EndofQueue() { - // @@protoc_insertion_point(destructor:dapi.message.EndofQueue) - SharedDtor(*this); -} -inline void EndofQueue::SharedDtor(MessageLite& self) { - EndofQueue& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - this_._impl_.~Impl_(); -} - -inline void* EndofQueue::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) EndofQueue(arena); -} -constexpr auto EndofQueue::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(EndofQueue), - alignof(EndofQueue)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<24> EndofQueue::_class_data_ = { - { - &_EndofQueue_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &EndofQueue::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &EndofQueue::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &EndofQueue::ByteSizeLong, - &EndofQueue::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(EndofQueue, _impl_._cached_size_), - true, - }, - "dapi.message.EndofQueue", -}; -const ::google::protobuf::internal::ClassData* EndofQueue::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 0, 0, 0, 2> EndofQueue::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 0, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967295, // skipmap - offsetof(decltype(_table_), field_names), // no field_entries - 0, // num_field_entries - 0, // num_aux_entries - offsetof(decltype(_table_), field_names), // no aux_entries - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::message::EndofQueue>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, - // no field_entries, or aux_entries - {{ - }}, -}; - -PROTOBUF_NOINLINE void EndofQueue::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.message.EndofQueue) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* EndofQueue::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const EndofQueue& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* EndofQueue::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const EndofQueue& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.message.EndofQueue) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.message.EndofQueue) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t EndofQueue::ByteSizeLong(const MessageLite& base) { - const EndofQueue& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t EndofQueue::ByteSizeLong() const { - const EndofQueue& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.message.EndofQueue) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void EndofQueue::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.message.EndofQueue) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void EndofQueue::CopyFrom(const EndofQueue& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.message.EndofQueue) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void EndofQueue::InternalSwap(EndofQueue* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); -} - -// =================================================================== - -class Message::_Internal { - public: - static constexpr ::int32_t kOneofCaseOffset = - PROTOBUF_FIELD_OFFSET(::dapi::message::Message, _impl_._oneof_case_); -}; - -void Message::set_allocated_initbroadcast(::dapi::init::ClientBroadcast* initbroadcast) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_msg(); - if (initbroadcast) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(initbroadcast)->GetArena(); - if (message_arena != submessage_arena) { - initbroadcast = ::google::protobuf::internal::GetOwnedMessage(message_arena, initbroadcast, submessage_arena); - } - set_has_initbroadcast(); - _impl_.msg_.initbroadcast_ = initbroadcast; - } - // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.initBroadcast) -} -void Message::clear_initbroadcast() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (msg_case() == kInitBroadcast) { - if (GetArena() == nullptr) { - delete _impl_.msg_.initbroadcast_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.initbroadcast_ != nullptr) { - _impl_.msg_.initbroadcast_->Clear(); - } - } - clear_has_msg(); - } -} -void Message::set_allocated_initresponse(::dapi::init::ServerResponse* initresponse) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_msg(); - if (initresponse) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(initresponse)->GetArena(); - if (message_arena != submessage_arena) { - initresponse = ::google::protobuf::internal::GetOwnedMessage(message_arena, initresponse, submessage_arena); - } - set_has_initresponse(); - _impl_.msg_.initresponse_ = initresponse; - } - // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.initResponse) -} -void Message::clear_initresponse() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (msg_case() == kInitResponse) { - if (GetArena() == nullptr) { - delete _impl_.msg_.initresponse_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.initresponse_ != nullptr) { - _impl_.msg_.initresponse_->Clear(); - } - } - clear_has_msg(); - } -} -void Message::set_allocated_frameupdate(::dapi::game::FrameUpdate* frameupdate) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_msg(); - if (frameupdate) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(frameupdate)->GetArena(); - if (message_arena != submessage_arena) { - frameupdate = ::google::protobuf::internal::GetOwnedMessage(message_arena, frameupdate, submessage_arena); - } - set_has_frameupdate(); - _impl_.msg_.frameupdate_ = frameupdate; - } - // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.frameUpdate) -} -void Message::clear_frameupdate() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (msg_case() == kFrameUpdate) { - if (GetArena() == nullptr) { - delete _impl_.msg_.frameupdate_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.frameupdate_ != nullptr) { - _impl_.msg_.frameupdate_->Clear(); - } - } - clear_has_msg(); - } -} -void Message::set_allocated_command(::dapi::commands::Command* command) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_msg(); - if (command) { - ::google::protobuf::Arena* submessage_arena = reinterpret_cast<::google::protobuf::MessageLite*>(command)->GetArena(); - if (message_arena != submessage_arena) { - command = ::google::protobuf::internal::GetOwnedMessage(message_arena, command, submessage_arena); - } - set_has_command(); - _impl_.msg_.command_ = command; - } - // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.command) -} -void Message::clear_command() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (msg_case() == kCommand) { - if (GetArena() == nullptr) { - delete _impl_.msg_.command_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.command_ != nullptr) { - _impl_.msg_.command_->Clear(); - } - } - clear_has_msg(); - } -} -void Message::set_allocated_endofqueue(::dapi::message::EndofQueue* endofqueue) { - ::google::protobuf::Arena* message_arena = GetArena(); - clear_msg(); - if (endofqueue) { - ::google::protobuf::Arena* submessage_arena = endofqueue->GetArena(); - if (message_arena != submessage_arena) { - endofqueue = ::google::protobuf::internal::GetOwnedMessage(message_arena, endofqueue, submessage_arena); - } - set_has_endofqueue(); - _impl_.msg_.endofqueue_ = endofqueue; - } - // @@protoc_insertion_point(field_set_allocated:dapi.message.Message.endOfQueue) -} -Message::Message(::google::protobuf::Arena* arena) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - SharedCtor(arena); - // @@protoc_insertion_point(arena_constructor:dapi.message.Message) -} -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, ::google::protobuf::Arena* arena, - const Impl_& from, const ::dapi::message::Message& from_msg) - : msg_{}, - _cached_size_{0}, - _oneof_case_{from._oneof_case_[0]} {} - -Message::Message( - ::google::protobuf::Arena* arena, - const Message& from) -#if defined(PROTOBUF_CUSTOM_VTABLE) - : ::google::protobuf::MessageLite(arena, _class_data_.base()) { -#else // PROTOBUF_CUSTOM_VTABLE - : ::google::protobuf::MessageLite(arena) { -#endif // PROTOBUF_CUSTOM_VTABLE - Message* const _this = this; - (void)_this; - _internal_metadata_.MergeFrom( - from._internal_metadata_); - new (&_impl_) Impl_(internal_visibility(), arena, from._impl_, from); - switch (msg_case()) { - case MSG_NOT_SET: - break; - case kInitBroadcast: - _impl_.msg_.initbroadcast_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ClientBroadcast>(arena, *from._impl_.msg_.initbroadcast_); - break; - case kInitResponse: - _impl_.msg_.initresponse_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ServerResponse>(arena, *from._impl_.msg_.initresponse_); - break; - case kFrameUpdate: - _impl_.msg_.frameupdate_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::game::FrameUpdate>(arena, *from._impl_.msg_.frameupdate_); - break; - case kCommand: - _impl_.msg_.command_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Command>(arena, *from._impl_.msg_.command_); - break; - case kEndOfQueue: - _impl_.msg_.endofqueue_ = ::google::protobuf::MessageLite::CopyConstruct<::dapi::message::EndofQueue>(arena, *from._impl_.msg_.endofqueue_); - break; - } - - // @@protoc_insertion_point(copy_constructor:dapi.message.Message) -} -inline PROTOBUF_NDEBUG_INLINE Message::Impl_::Impl_( - ::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena) - : msg_{}, - _cached_size_{0}, - _oneof_case_{} {} - -inline void Message::SharedCtor(::_pb::Arena* arena) { - new (&_impl_) Impl_(internal_visibility(), arena); -} -Message::~Message() { - // @@protoc_insertion_point(destructor:dapi.message.Message) - SharedDtor(*this); -} -inline void Message::SharedDtor(MessageLite& self) { - Message& this_ = static_cast(self); - this_._internal_metadata_.Delete(); - ABSL_DCHECK(this_.GetArena() == nullptr); - if (this_.has_msg()) { - this_.clear_msg(); - } - this_._impl_.~Impl_(); -} - -void Message::clear_msg() { -// @@protoc_insertion_point(one_of_clear_start:dapi.message.Message) - ::google::protobuf::internal::TSanWrite(&_impl_); - switch (msg_case()) { - case kInitBroadcast: { - if (GetArena() == nullptr) { - delete _impl_.msg_.initbroadcast_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.initbroadcast_ != nullptr) { - _impl_.msg_.initbroadcast_->Clear(); - } - } - break; - } - case kInitResponse: { - if (GetArena() == nullptr) { - delete _impl_.msg_.initresponse_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.initresponse_ != nullptr) { - _impl_.msg_.initresponse_->Clear(); - } - } - break; - } - case kFrameUpdate: { - if (GetArena() == nullptr) { - delete _impl_.msg_.frameupdate_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.frameupdate_ != nullptr) { - _impl_.msg_.frameupdate_->Clear(); - } - } - break; - } - case kCommand: { - if (GetArena() == nullptr) { - delete _impl_.msg_.command_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.command_ != nullptr) { - _impl_.msg_.command_->Clear(); - } - } - break; - } - case kEndOfQueue: { - if (GetArena() == nullptr) { - delete _impl_.msg_.endofqueue_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.endofqueue_ != nullptr) { - _impl_.msg_.endofqueue_->Clear(); - } - } - break; - } - case MSG_NOT_SET: { - break; - } - } - _impl_._oneof_case_[0] = MSG_NOT_SET; -} - - -inline void* Message::PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena) { - return ::new (mem) Message(arena); -} -constexpr auto Message::InternalNewImpl_() { - return ::google::protobuf::internal::MessageCreator::ZeroInit(sizeof(Message), - alignof(Message)); -} -PROTOBUF_CONSTINIT -PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::google::protobuf::internal::ClassDataLite<21> Message::_class_data_ = { - { - &_Message_default_instance_._instance, - &_table_.header, - nullptr, // OnDemandRegisterArenaDtor - nullptr, // IsInitialized - &Message::MergeImpl, - ::google::protobuf::MessageLite::GetNewImpl(), -#if defined(PROTOBUF_CUSTOM_VTABLE) - &Message::SharedDtor, - ::google::protobuf::MessageLite::GetClearImpl(), &Message::ByteSizeLong, - &Message::_InternalSerialize, -#endif // PROTOBUF_CUSTOM_VTABLE - PROTOBUF_FIELD_OFFSET(Message, _impl_._cached_size_), - true, - }, - "dapi.message.Message", -}; -const ::google::protobuf::internal::ClassData* Message::GetClassData() const { - return _class_data_.base(); -} -PROTOBUF_CONSTINIT PROTOBUF_ATTRIBUTE_INIT_PRIORITY1 -const ::_pbi::TcParseTable<0, 5, 5, 0, 2> Message::_table_ = { - { - 0, // no _has_bits_ - 0, // no _extensions_ - 5, 0, // max_field_number, fast_idx_mask - offsetof(decltype(_table_), field_lookup_table), - 4294967264, // skipmap - offsetof(decltype(_table_), field_entries), - 5, // num_field_entries - 5, // num_aux_entries - offsetof(decltype(_table_), aux_entries), - _class_data_.base(), - nullptr, // post_loop_handler - ::_pbi::TcParser::GenericFallbackLite, // fallback - #ifdef PROTOBUF_PREFETCH_PARSE_TABLE - ::_pbi::TcParser::GetTable<::dapi::message::Message>(), // to_prefetch - #endif // PROTOBUF_PREFETCH_PARSE_TABLE - }, {{ - {::_pbi::TcParser::MiniParse, {}}, - }}, {{ - 65535, 65535 - }}, {{ - // .dapi.init.ClientBroadcast initBroadcast = 1; - {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.initbroadcast_), _Internal::kOneofCaseOffset + 0, 0, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.init.ServerResponse initResponse = 2; - {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.initresponse_), _Internal::kOneofCaseOffset + 0, 1, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.game.FrameUpdate frameUpdate = 3; - {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.frameupdate_), _Internal::kOneofCaseOffset + 0, 2, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.commands.Command command = 4; - {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.command_), _Internal::kOneofCaseOffset + 0, 3, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - // .dapi.message.EndofQueue endOfQueue = 5; - {PROTOBUF_FIELD_OFFSET(Message, _impl_.msg_.endofqueue_), _Internal::kOneofCaseOffset + 0, 4, - (0 | ::_fl::kFcOneof | ::_fl::kMessage | ::_fl::kTvTable)}, - }}, {{ - {::_pbi::TcParser::GetTable<::dapi::init::ClientBroadcast>()}, - {::_pbi::TcParser::GetTable<::dapi::init::ServerResponse>()}, - {::_pbi::TcParser::GetTable<::dapi::game::FrameUpdate>()}, - {::_pbi::TcParser::GetTable<::dapi::commands::Command>()}, - {::_pbi::TcParser::GetTable<::dapi::message::EndofQueue>()}, - }}, {{ - }}, -}; - -PROTOBUF_NOINLINE void Message::Clear() { -// @@protoc_insertion_point(message_clear_start:dapi.message.Message) - ::google::protobuf::internal::TSanWrite(&_impl_); - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - clear_msg(); - _internal_metadata_.Clear(); -} - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::uint8_t* Message::_InternalSerialize( - const MessageLite& base, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) { - const Message& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::uint8_t* Message::_InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - const Message& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(serialize_to_array_start:dapi.message.Message) - ::uint32_t cached_has_bits = 0; - (void)cached_has_bits; - - switch (this_.msg_case()) { - case kInitBroadcast: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 1, *this_._impl_.msg_.initbroadcast_, this_._impl_.msg_.initbroadcast_->GetCachedSize(), target, - stream); - break; - } - case kInitResponse: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 2, *this_._impl_.msg_.initresponse_, this_._impl_.msg_.initresponse_->GetCachedSize(), target, - stream); - break; - } - case kFrameUpdate: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 3, *this_._impl_.msg_.frameupdate_, this_._impl_.msg_.frameupdate_->GetCachedSize(), target, - stream); - break; - } - case kCommand: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 4, *this_._impl_.msg_.command_, this_._impl_.msg_.command_->GetCachedSize(), target, - stream); - break; - } - case kEndOfQueue: { - target = ::google::protobuf::internal::WireFormatLite::InternalWriteMessage( - 5, *this_._impl_.msg_.endofqueue_, this_._impl_.msg_.endofqueue_->GetCachedSize(), target, - stream); - break; - } - default: - break; - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - target = stream->WriteRaw( - this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).data(), - static_cast(this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:dapi.message.Message) - return target; - } - -#if defined(PROTOBUF_CUSTOM_VTABLE) - ::size_t Message::ByteSizeLong(const MessageLite& base) { - const Message& this_ = static_cast(base); -#else // PROTOBUF_CUSTOM_VTABLE - ::size_t Message::ByteSizeLong() const { - const Message& this_ = *this; -#endif // PROTOBUF_CUSTOM_VTABLE - // @@protoc_insertion_point(message_byte_size_start:dapi.message.Message) - ::size_t total_size = 0; - - ::uint32_t cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void)cached_has_bits; - - switch (this_.msg_case()) { - // .dapi.init.ClientBroadcast initBroadcast = 1; - case kInitBroadcast: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.initbroadcast_); - break; - } - // .dapi.init.ServerResponse initResponse = 2; - case kInitResponse: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.initresponse_); - break; - } - // .dapi.game.FrameUpdate frameUpdate = 3; - case kFrameUpdate: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.frameupdate_); - break; - } - // .dapi.commands.Command command = 4; - case kCommand: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.command_); - break; - } - // .dapi.message.EndofQueue endOfQueue = 5; - case kEndOfQueue: { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize(*this_._impl_.msg_.endofqueue_); - break; - } - case MSG_NOT_SET: { - break; - } - } - if (PROTOBUF_PREDICT_FALSE(this_._internal_metadata_.have_unknown_fields())) { - total_size += this_._internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString).size(); - } - this_._impl_._cached_size_.Set(::_pbi::ToCachedSize(total_size)); - return total_size; - } - -void Message::MergeImpl(::google::protobuf::MessageLite& to_msg, const ::google::protobuf::MessageLite& from_msg) { - auto* const _this = static_cast(&to_msg); - auto& from = static_cast(from_msg); - ::google::protobuf::Arena* arena = _this->GetArena(); - // @@protoc_insertion_point(class_specific_merge_from_start:dapi.message.Message) - ABSL_DCHECK_NE(&from, _this); - ::uint32_t cached_has_bits = 0; - (void) cached_has_bits; - - if (const uint32_t oneof_from_case = from._impl_._oneof_case_[0]) { - const uint32_t oneof_to_case = _this->_impl_._oneof_case_[0]; - const bool oneof_needs_init = oneof_to_case != oneof_from_case; - if (oneof_needs_init) { - if (oneof_to_case != 0) { - _this->clear_msg(); - } - _this->_impl_._oneof_case_[0] = oneof_from_case; - } - - switch (oneof_from_case) { - case kInitBroadcast: { - if (oneof_needs_init) { - _this->_impl_.msg_.initbroadcast_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ClientBroadcast>(arena, *from._impl_.msg_.initbroadcast_); - } else { - _this->_impl_.msg_.initbroadcast_->MergeFrom(from._internal_initbroadcast()); - } - break; - } - case kInitResponse: { - if (oneof_needs_init) { - _this->_impl_.msg_.initresponse_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::init::ServerResponse>(arena, *from._impl_.msg_.initresponse_); - } else { - _this->_impl_.msg_.initresponse_->MergeFrom(from._internal_initresponse()); - } - break; - } - case kFrameUpdate: { - if (oneof_needs_init) { - _this->_impl_.msg_.frameupdate_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::game::FrameUpdate>(arena, *from._impl_.msg_.frameupdate_); - } else { - _this->_impl_.msg_.frameupdate_->MergeFrom(from._internal_frameupdate()); - } - break; - } - case kCommand: { - if (oneof_needs_init) { - _this->_impl_.msg_.command_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::commands::Command>(arena, *from._impl_.msg_.command_); - } else { - _this->_impl_.msg_.command_->MergeFrom(from._internal_command()); - } - break; - } - case kEndOfQueue: { - if (oneof_needs_init) { - _this->_impl_.msg_.endofqueue_ = - ::google::protobuf::MessageLite::CopyConstruct<::dapi::message::EndofQueue>(arena, *from._impl_.msg_.endofqueue_); - } else { - _this->_impl_.msg_.endofqueue_->MergeFrom(from._internal_endofqueue()); - } - break; - } - case MSG_NOT_SET: - break; - } - } - _this->_internal_metadata_.MergeFrom(from._internal_metadata_); -} - -void Message::CopyFrom(const Message& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:dapi.message.Message) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - - -void Message::InternalSwap(Message* PROTOBUF_RESTRICT other) { - using std::swap; - _internal_metadata_.InternalSwap(&other->_internal_metadata_); - swap(_impl_.msg_, other->_impl_.msg_); - swap(_impl_._oneof_case_[0], other->_impl_._oneof_case_[0]); -} - -// @@protoc_insertion_point(namespace_scope) -} // namespace message -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google -// @@protoc_insertion_point(global_scope) -#include "google/protobuf/port_undef.inc" diff --git a/Source/dapi/Backend/Messages/generated/message.pb.h b/Source/dapi/Backend/Messages/generated/message.pb.h deleted file mode 100644 index cea94c880..000000000 --- a/Source/dapi/Backend/Messages/generated/message.pb.h +++ /dev/null @@ -1,924 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// NO CHECKED-IN PROTOBUF GENCODE -// source: message.proto -// Protobuf C++ Version: 5.29.3 - -#ifndef message_2eproto_2epb_2eh -#define message_2eproto_2epb_2eh - -#include -#include -#include -#include - -#include "google/protobuf/runtime_version.h" -#if PROTOBUF_VERSION != 5029003 -#error "Protobuf C++ gencode is built with an incompatible version of" -#error "Protobuf C++ headers/runtime. See" -#error "https://protobuf.dev/support/cross-version-runtime-guarantee/#cpp" -#endif -#include "google/protobuf/io/coded_stream.h" -#include "google/protobuf/arena.h" -#include "google/protobuf/arenastring.h" -#include "google/protobuf/generated_message_tctable_decl.h" -#include "google/protobuf/generated_message_util.h" -#include "google/protobuf/metadata_lite.h" -#include "google/protobuf/message_lite.h" -#include "google/protobuf/repeated_field.h" // IWYU pragma: export -#include "google/protobuf/extension_set.h" // IWYU pragma: export -#include "init.pb.h" -#include "game.pb.h" -#include "command.pb.h" -// @@protoc_insertion_point(includes) - -// Must be included last. -#include "google/protobuf/port_def.inc" - -#define PROTOBUF_INTERNAL_EXPORT_message_2eproto - -namespace google { -namespace protobuf { -namespace internal { -template -::absl::string_view GetAnyMessageName(); -} // namespace internal -} // namespace protobuf -} // namespace google - -// Internal implementation detail -- do not use these members. -struct TableStruct_message_2eproto { - static const ::uint32_t offsets[]; -}; -namespace dapi { -namespace message { -class EndofQueue; -struct EndofQueueDefaultTypeInternal; -extern EndofQueueDefaultTypeInternal _EndofQueue_default_instance_; -class Message; -struct MessageDefaultTypeInternal; -extern MessageDefaultTypeInternal _Message_default_instance_; -} // namespace message -} // namespace dapi -namespace google { -namespace protobuf { -} // namespace protobuf -} // namespace google - -namespace dapi { -namespace message { - -// =================================================================== - - -// ------------------------------------------------------------------- - -class EndofQueue final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.message.EndofQueue) */ { - public: - inline EndofQueue() : EndofQueue(nullptr) {} - ~EndofQueue() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(EndofQueue* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(EndofQueue)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR EndofQueue( - ::google::protobuf::internal::ConstantInitialized); - - inline EndofQueue(const EndofQueue& from) : EndofQueue(nullptr, from) {} - inline EndofQueue(EndofQueue&& from) noexcept - : EndofQueue(nullptr, std::move(from)) {} - inline EndofQueue& operator=(const EndofQueue& from) { - CopyFrom(from); - return *this; - } - inline EndofQueue& operator=(EndofQueue&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const EndofQueue& default_instance() { - return *internal_default_instance(); - } - static inline const EndofQueue* internal_default_instance() { - return reinterpret_cast( - &_EndofQueue_default_instance_); - } - static constexpr int kIndexInFileMessages = 0; - friend void swap(EndofQueue& a, EndofQueue& b) { a.Swap(&b); } - inline void Swap(EndofQueue* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(EndofQueue* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - EndofQueue* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const EndofQueue& from); - void MergeFrom(const EndofQueue& from) { EndofQueue::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(EndofQueue* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.message.EndofQueue"; } - - protected: - explicit EndofQueue(::google::protobuf::Arena* arena); - EndofQueue(::google::protobuf::Arena* arena, const EndofQueue& from); - EndofQueue(::google::protobuf::Arena* arena, EndofQueue&& from) noexcept - : EndofQueue(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<24> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - // @@protoc_insertion_point(class_scope:dapi.message.EndofQueue) - private: - class _Internal; - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 0, 0, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const EndofQueue& from_msg); - ::google::protobuf::internal::CachedSize _cached_size_; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_message_2eproto; -}; -// ------------------------------------------------------------------- - -class Message final : public ::google::protobuf::MessageLite -/* @@protoc_insertion_point(class_definition:dapi.message.Message) */ { - public: - inline Message() : Message(nullptr) {} - ~Message() PROTOBUF_FINAL; - -#if defined(PROTOBUF_CUSTOM_VTABLE) - void operator delete(Message* msg, std::destroying_delete_t) { - SharedDtor(*msg); - ::google::protobuf::internal::SizedDelete(msg, sizeof(Message)); - } -#endif - - template - explicit PROTOBUF_CONSTEXPR Message( - ::google::protobuf::internal::ConstantInitialized); - - inline Message(const Message& from) : Message(nullptr, from) {} - inline Message(Message&& from) noexcept - : Message(nullptr, std::move(from)) {} - inline Message& operator=(const Message& from) { - CopyFrom(from); - return *this; - } - inline Message& operator=(Message&& from) noexcept { - if (this == &from) return *this; - if (::google::protobuf::internal::CanMoveWithInternalSwap(GetArena(), from.GetArena())) { - InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - - inline const std::string& unknown_fields() const - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.unknown_fields(::google::protobuf::internal::GetEmptyString); - } - inline std::string* mutable_unknown_fields() - ABSL_ATTRIBUTE_LIFETIME_BOUND { - return _internal_metadata_.mutable_unknown_fields(); - } - - static const Message& default_instance() { - return *internal_default_instance(); - } - enum MsgCase { - kInitBroadcast = 1, - kInitResponse = 2, - kFrameUpdate = 3, - kCommand = 4, - kEndOfQueue = 5, - MSG_NOT_SET = 0, - }; - static inline const Message* internal_default_instance() { - return reinterpret_cast( - &_Message_default_instance_); - } - static constexpr int kIndexInFileMessages = 1; - friend void swap(Message& a, Message& b) { a.Swap(&b); } - inline void Swap(Message* other) { - if (other == this) return; - if (::google::protobuf::internal::CanUseInternalSwap(GetArena(), other->GetArena())) { - InternalSwap(other); - } else { - ::google::protobuf::internal::GenericSwap(this, other); - } - } - void UnsafeArenaSwap(Message* other) { - if (other == this) return; - ABSL_DCHECK(GetArena() == other->GetArena()); - InternalSwap(other); - } - - // implements Message ---------------------------------------------- - - Message* New(::google::protobuf::Arena* arena = nullptr) const { - return ::google::protobuf::MessageLite::DefaultConstruct(arena); - } - void CopyFrom(const Message& from); - void MergeFrom(const Message& from) { Message::MergeImpl(*this, from); } - - private: - static void MergeImpl(::google::protobuf::MessageLite& to_msg, - const ::google::protobuf::MessageLite& from_msg); - - public: - bool IsInitialized() const { - return true; - } - ABSL_ATTRIBUTE_REINITIALIZES void Clear() PROTOBUF_FINAL; - #if defined(PROTOBUF_CUSTOM_VTABLE) - private: - static ::size_t ByteSizeLong(const ::google::protobuf::MessageLite& msg); - static ::uint8_t* _InternalSerialize( - const MessageLite& msg, ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream); - - public: - ::size_t ByteSizeLong() const { return ByteSizeLong(*this); } - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const { - return _InternalSerialize(*this, target, stream); - } - #else // PROTOBUF_CUSTOM_VTABLE - ::size_t ByteSizeLong() const final; - ::uint8_t* _InternalSerialize( - ::uint8_t* target, - ::google::protobuf::io::EpsCopyOutputStream* stream) const final; - #endif // PROTOBUF_CUSTOM_VTABLE - int GetCachedSize() const { return _impl_._cached_size_.Get(); } - - private: - void SharedCtor(::google::protobuf::Arena* arena); - static void SharedDtor(MessageLite& self); - void InternalSwap(Message* other); - private: - template - friend ::absl::string_view( - ::google::protobuf::internal::GetAnyMessageName)(); - static ::absl::string_view FullMessageName() { return "dapi.message.Message"; } - - protected: - explicit Message(::google::protobuf::Arena* arena); - Message(::google::protobuf::Arena* arena, const Message& from); - Message(::google::protobuf::Arena* arena, Message&& from) noexcept - : Message(arena) { - *this = ::std::move(from); - } - const ::google::protobuf::internal::ClassData* GetClassData() const PROTOBUF_FINAL; - static void* PlacementNew_(const void*, void* mem, - ::google::protobuf::Arena* arena); - static constexpr auto InternalNewImpl_(); - static const ::google::protobuf::internal::ClassDataLite<21> _class_data_; - - public: - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - enum : int { - kInitBroadcastFieldNumber = 1, - kInitResponseFieldNumber = 2, - kFrameUpdateFieldNumber = 3, - kCommandFieldNumber = 4, - kEndOfQueueFieldNumber = 5, - }; - // .dapi.init.ClientBroadcast initBroadcast = 1; - bool has_initbroadcast() const; - private: - bool _internal_has_initbroadcast() const; - - public: - void clear_initbroadcast() ; - const ::dapi::init::ClientBroadcast& initbroadcast() const; - PROTOBUF_NODISCARD ::dapi::init::ClientBroadcast* release_initbroadcast(); - ::dapi::init::ClientBroadcast* mutable_initbroadcast(); - void set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value); - void unsafe_arena_set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value); - ::dapi::init::ClientBroadcast* unsafe_arena_release_initbroadcast(); - - private: - const ::dapi::init::ClientBroadcast& _internal_initbroadcast() const; - ::dapi::init::ClientBroadcast* _internal_mutable_initbroadcast(); - - public: - // .dapi.init.ServerResponse initResponse = 2; - bool has_initresponse() const; - private: - bool _internal_has_initresponse() const; - - public: - void clear_initresponse() ; - const ::dapi::init::ServerResponse& initresponse() const; - PROTOBUF_NODISCARD ::dapi::init::ServerResponse* release_initresponse(); - ::dapi::init::ServerResponse* mutable_initresponse(); - void set_allocated_initresponse(::dapi::init::ServerResponse* value); - void unsafe_arena_set_allocated_initresponse(::dapi::init::ServerResponse* value); - ::dapi::init::ServerResponse* unsafe_arena_release_initresponse(); - - private: - const ::dapi::init::ServerResponse& _internal_initresponse() const; - ::dapi::init::ServerResponse* _internal_mutable_initresponse(); - - public: - // .dapi.game.FrameUpdate frameUpdate = 3; - bool has_frameupdate() const; - private: - bool _internal_has_frameupdate() const; - - public: - void clear_frameupdate() ; - const ::dapi::game::FrameUpdate& frameupdate() const; - PROTOBUF_NODISCARD ::dapi::game::FrameUpdate* release_frameupdate(); - ::dapi::game::FrameUpdate* mutable_frameupdate(); - void set_allocated_frameupdate(::dapi::game::FrameUpdate* value); - void unsafe_arena_set_allocated_frameupdate(::dapi::game::FrameUpdate* value); - ::dapi::game::FrameUpdate* unsafe_arena_release_frameupdate(); - - private: - const ::dapi::game::FrameUpdate& _internal_frameupdate() const; - ::dapi::game::FrameUpdate* _internal_mutable_frameupdate(); - - public: - // .dapi.commands.Command command = 4; - bool has_command() const; - private: - bool _internal_has_command() const; - - public: - void clear_command() ; - const ::dapi::commands::Command& command() const; - PROTOBUF_NODISCARD ::dapi::commands::Command* release_command(); - ::dapi::commands::Command* mutable_command(); - void set_allocated_command(::dapi::commands::Command* value); - void unsafe_arena_set_allocated_command(::dapi::commands::Command* value); - ::dapi::commands::Command* unsafe_arena_release_command(); - - private: - const ::dapi::commands::Command& _internal_command() const; - ::dapi::commands::Command* _internal_mutable_command(); - - public: - // .dapi.message.EndofQueue endOfQueue = 5; - bool has_endofqueue() const; - private: - bool _internal_has_endofqueue() const; - - public: - void clear_endofqueue() ; - const ::dapi::message::EndofQueue& endofqueue() const; - PROTOBUF_NODISCARD ::dapi::message::EndofQueue* release_endofqueue(); - ::dapi::message::EndofQueue* mutable_endofqueue(); - void set_allocated_endofqueue(::dapi::message::EndofQueue* value); - void unsafe_arena_set_allocated_endofqueue(::dapi::message::EndofQueue* value); - ::dapi::message::EndofQueue* unsafe_arena_release_endofqueue(); - - private: - const ::dapi::message::EndofQueue& _internal_endofqueue() const; - ::dapi::message::EndofQueue* _internal_mutable_endofqueue(); - - public: - void clear_msg(); - MsgCase msg_case() const; - // @@protoc_insertion_point(class_scope:dapi.message.Message) - private: - class _Internal; - void set_has_initbroadcast(); - void set_has_initresponse(); - void set_has_frameupdate(); - void set_has_command(); - void set_has_endofqueue(); - inline bool has_msg() const; - inline void clear_has_msg(); - friend class ::google::protobuf::internal::TcParser; - static const ::google::protobuf::internal::TcParseTable< - 0, 5, 5, - 0, 2> - _table_; - - friend class ::google::protobuf::MessageLite; - friend class ::google::protobuf::Arena; - template - friend class ::google::protobuf::Arena::InternalHelper; - using InternalArenaConstructable_ = void; - using DestructorSkippable_ = void; - struct Impl_ { - inline explicit constexpr Impl_( - ::google::protobuf::internal::ConstantInitialized) noexcept; - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena); - inline explicit Impl_(::google::protobuf::internal::InternalVisibility visibility, - ::google::protobuf::Arena* arena, const Impl_& from, - const Message& from_msg); - union MsgUnion { - constexpr MsgUnion() : _constinit_{} {} - ::google::protobuf::internal::ConstantInitialized _constinit_; - ::dapi::init::ClientBroadcast* initbroadcast_; - ::dapi::init::ServerResponse* initresponse_; - ::dapi::game::FrameUpdate* frameupdate_; - ::dapi::commands::Command* command_; - ::dapi::message::EndofQueue* endofqueue_; - } msg_; - ::google::protobuf::internal::CachedSize _cached_size_; - ::uint32_t _oneof_case_[1]; - PROTOBUF_TSAN_DECLARE_MEMBER - }; - union { Impl_ _impl_; }; - friend struct ::TableStruct_message_2eproto; -}; - -// =================================================================== - - - - -// =================================================================== - - -#ifdef __GNUC__ -#pragma GCC diagnostic push -#pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// EndofQueue - -// ------------------------------------------------------------------- - -// Message - -// .dapi.init.ClientBroadcast initBroadcast = 1; -inline bool Message::has_initbroadcast() const { - return msg_case() == kInitBroadcast; -} -inline bool Message::_internal_has_initbroadcast() const { - return msg_case() == kInitBroadcast; -} -inline void Message::set_has_initbroadcast() { - _impl_._oneof_case_[0] = kInitBroadcast; -} -inline ::dapi::init::ClientBroadcast* Message::release_initbroadcast() { - // @@protoc_insertion_point(field_release:dapi.message.Message.initBroadcast) - if (msg_case() == kInitBroadcast) { - clear_has_msg(); - auto* temp = _impl_.msg_.initbroadcast_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.msg_.initbroadcast_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::init::ClientBroadcast& Message::_internal_initbroadcast() const { - return msg_case() == kInitBroadcast ? *_impl_.msg_.initbroadcast_ : reinterpret_cast<::dapi::init::ClientBroadcast&>(::dapi::init::_ClientBroadcast_default_instance_); -} -inline const ::dapi::init::ClientBroadcast& Message::initbroadcast() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.message.Message.initBroadcast) - return _internal_initbroadcast(); -} -inline ::dapi::init::ClientBroadcast* Message::unsafe_arena_release_initbroadcast() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.initBroadcast) - if (msg_case() == kInitBroadcast) { - clear_has_msg(); - auto* temp = _impl_.msg_.initbroadcast_; - _impl_.msg_.initbroadcast_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message::unsafe_arena_set_allocated_initbroadcast(::dapi::init::ClientBroadcast* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_msg(); - if (value) { - set_has_initbroadcast(); - _impl_.msg_.initbroadcast_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.initBroadcast) -} -inline ::dapi::init::ClientBroadcast* Message::_internal_mutable_initbroadcast() { - if (msg_case() != kInitBroadcast) { - clear_msg(); - set_has_initbroadcast(); - _impl_.msg_.initbroadcast_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::init::ClientBroadcast>(GetArena()); - } - return _impl_.msg_.initbroadcast_; -} -inline ::dapi::init::ClientBroadcast* Message::mutable_initbroadcast() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::init::ClientBroadcast* _msg = _internal_mutable_initbroadcast(); - // @@protoc_insertion_point(field_mutable:dapi.message.Message.initBroadcast) - return _msg; -} - -// .dapi.init.ServerResponse initResponse = 2; -inline bool Message::has_initresponse() const { - return msg_case() == kInitResponse; -} -inline bool Message::_internal_has_initresponse() const { - return msg_case() == kInitResponse; -} -inline void Message::set_has_initresponse() { - _impl_._oneof_case_[0] = kInitResponse; -} -inline ::dapi::init::ServerResponse* Message::release_initresponse() { - // @@protoc_insertion_point(field_release:dapi.message.Message.initResponse) - if (msg_case() == kInitResponse) { - clear_has_msg(); - auto* temp = _impl_.msg_.initresponse_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.msg_.initresponse_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::init::ServerResponse& Message::_internal_initresponse() const { - return msg_case() == kInitResponse ? *_impl_.msg_.initresponse_ : reinterpret_cast<::dapi::init::ServerResponse&>(::dapi::init::_ServerResponse_default_instance_); -} -inline const ::dapi::init::ServerResponse& Message::initresponse() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.message.Message.initResponse) - return _internal_initresponse(); -} -inline ::dapi::init::ServerResponse* Message::unsafe_arena_release_initresponse() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.initResponse) - if (msg_case() == kInitResponse) { - clear_has_msg(); - auto* temp = _impl_.msg_.initresponse_; - _impl_.msg_.initresponse_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message::unsafe_arena_set_allocated_initresponse(::dapi::init::ServerResponse* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_msg(); - if (value) { - set_has_initresponse(); - _impl_.msg_.initresponse_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.initResponse) -} -inline ::dapi::init::ServerResponse* Message::_internal_mutable_initresponse() { - if (msg_case() != kInitResponse) { - clear_msg(); - set_has_initresponse(); - _impl_.msg_.initresponse_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::init::ServerResponse>(GetArena()); - } - return _impl_.msg_.initresponse_; -} -inline ::dapi::init::ServerResponse* Message::mutable_initresponse() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::init::ServerResponse* _msg = _internal_mutable_initresponse(); - // @@protoc_insertion_point(field_mutable:dapi.message.Message.initResponse) - return _msg; -} - -// .dapi.game.FrameUpdate frameUpdate = 3; -inline bool Message::has_frameupdate() const { - return msg_case() == kFrameUpdate; -} -inline bool Message::_internal_has_frameupdate() const { - return msg_case() == kFrameUpdate; -} -inline void Message::set_has_frameupdate() { - _impl_._oneof_case_[0] = kFrameUpdate; -} -inline ::dapi::game::FrameUpdate* Message::release_frameupdate() { - // @@protoc_insertion_point(field_release:dapi.message.Message.frameUpdate) - if (msg_case() == kFrameUpdate) { - clear_has_msg(); - auto* temp = _impl_.msg_.frameupdate_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.msg_.frameupdate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::game::FrameUpdate& Message::_internal_frameupdate() const { - return msg_case() == kFrameUpdate ? *_impl_.msg_.frameupdate_ : reinterpret_cast<::dapi::game::FrameUpdate&>(::dapi::game::_FrameUpdate_default_instance_); -} -inline const ::dapi::game::FrameUpdate& Message::frameupdate() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.message.Message.frameUpdate) - return _internal_frameupdate(); -} -inline ::dapi::game::FrameUpdate* Message::unsafe_arena_release_frameupdate() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.frameUpdate) - if (msg_case() == kFrameUpdate) { - clear_has_msg(); - auto* temp = _impl_.msg_.frameupdate_; - _impl_.msg_.frameupdate_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message::unsafe_arena_set_allocated_frameupdate(::dapi::game::FrameUpdate* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_msg(); - if (value) { - set_has_frameupdate(); - _impl_.msg_.frameupdate_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.frameUpdate) -} -inline ::dapi::game::FrameUpdate* Message::_internal_mutable_frameupdate() { - if (msg_case() != kFrameUpdate) { - clear_msg(); - set_has_frameupdate(); - _impl_.msg_.frameupdate_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::game::FrameUpdate>(GetArena()); - } - return _impl_.msg_.frameupdate_; -} -inline ::dapi::game::FrameUpdate* Message::mutable_frameupdate() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::game::FrameUpdate* _msg = _internal_mutable_frameupdate(); - // @@protoc_insertion_point(field_mutable:dapi.message.Message.frameUpdate) - return _msg; -} - -// .dapi.commands.Command command = 4; -inline bool Message::has_command() const { - return msg_case() == kCommand; -} -inline bool Message::_internal_has_command() const { - return msg_case() == kCommand; -} -inline void Message::set_has_command() { - _impl_._oneof_case_[0] = kCommand; -} -inline ::dapi::commands::Command* Message::release_command() { - // @@protoc_insertion_point(field_release:dapi.message.Message.command) - if (msg_case() == kCommand) { - clear_has_msg(); - auto* temp = _impl_.msg_.command_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.msg_.command_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::commands::Command& Message::_internal_command() const { - return msg_case() == kCommand ? *_impl_.msg_.command_ : reinterpret_cast<::dapi::commands::Command&>(::dapi::commands::_Command_default_instance_); -} -inline const ::dapi::commands::Command& Message::command() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.message.Message.command) - return _internal_command(); -} -inline ::dapi::commands::Command* Message::unsafe_arena_release_command() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.command) - if (msg_case() == kCommand) { - clear_has_msg(); - auto* temp = _impl_.msg_.command_; - _impl_.msg_.command_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message::unsafe_arena_set_allocated_command(::dapi::commands::Command* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_msg(); - if (value) { - set_has_command(); - _impl_.msg_.command_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.command) -} -inline ::dapi::commands::Command* Message::_internal_mutable_command() { - if (msg_case() != kCommand) { - clear_msg(); - set_has_command(); - _impl_.msg_.command_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::commands::Command>(GetArena()); - } - return _impl_.msg_.command_; -} -inline ::dapi::commands::Command* Message::mutable_command() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::commands::Command* _msg = _internal_mutable_command(); - // @@protoc_insertion_point(field_mutable:dapi.message.Message.command) - return _msg; -} - -// .dapi.message.EndofQueue endOfQueue = 5; -inline bool Message::has_endofqueue() const { - return msg_case() == kEndOfQueue; -} -inline bool Message::_internal_has_endofqueue() const { - return msg_case() == kEndOfQueue; -} -inline void Message::set_has_endofqueue() { - _impl_._oneof_case_[0] = kEndOfQueue; -} -inline void Message::clear_endofqueue() { - ::google::protobuf::internal::TSanWrite(&_impl_); - if (msg_case() == kEndOfQueue) { - if (GetArena() == nullptr) { - delete _impl_.msg_.endofqueue_; - } else if (::google::protobuf::internal::DebugHardenClearOneofMessageOnArena()) { - if (_impl_.msg_.endofqueue_ != nullptr) { - _impl_.msg_.endofqueue_->Clear(); - } - } - clear_has_msg(); - } -} -inline ::dapi::message::EndofQueue* Message::release_endofqueue() { - // @@protoc_insertion_point(field_release:dapi.message.Message.endOfQueue) - if (msg_case() == kEndOfQueue) { - clear_has_msg(); - auto* temp = _impl_.msg_.endofqueue_; - if (GetArena() != nullptr) { - temp = ::google::protobuf::internal::DuplicateIfNonNull(temp); - } - _impl_.msg_.endofqueue_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline const ::dapi::message::EndofQueue& Message::_internal_endofqueue() const { - return msg_case() == kEndOfQueue ? *_impl_.msg_.endofqueue_ : reinterpret_cast<::dapi::message::EndofQueue&>(::dapi::message::_EndofQueue_default_instance_); -} -inline const ::dapi::message::EndofQueue& Message::endofqueue() const ABSL_ATTRIBUTE_LIFETIME_BOUND { - // @@protoc_insertion_point(field_get:dapi.message.Message.endOfQueue) - return _internal_endofqueue(); -} -inline ::dapi::message::EndofQueue* Message::unsafe_arena_release_endofqueue() { - // @@protoc_insertion_point(field_unsafe_arena_release:dapi.message.Message.endOfQueue) - if (msg_case() == kEndOfQueue) { - clear_has_msg(); - auto* temp = _impl_.msg_.endofqueue_; - _impl_.msg_.endofqueue_ = nullptr; - return temp; - } else { - return nullptr; - } -} -inline void Message::unsafe_arena_set_allocated_endofqueue(::dapi::message::EndofQueue* value) { - // We rely on the oneof clear method to free the earlier contents - // of this oneof. We can directly use the pointer we're given to - // set the new value. - clear_msg(); - if (value) { - set_has_endofqueue(); - _impl_.msg_.endofqueue_ = value; - } - // @@protoc_insertion_point(field_unsafe_arena_set_allocated:dapi.message.Message.endOfQueue) -} -inline ::dapi::message::EndofQueue* Message::_internal_mutable_endofqueue() { - if (msg_case() != kEndOfQueue) { - clear_msg(); - set_has_endofqueue(); - _impl_.msg_.endofqueue_ = - ::google::protobuf::MessageLite::DefaultConstruct<::dapi::message::EndofQueue>(GetArena()); - } - return _impl_.msg_.endofqueue_; -} -inline ::dapi::message::EndofQueue* Message::mutable_endofqueue() ABSL_ATTRIBUTE_LIFETIME_BOUND { - ::dapi::message::EndofQueue* _msg = _internal_mutable_endofqueue(); - // @@protoc_insertion_point(field_mutable:dapi.message.Message.endOfQueue) - return _msg; -} - -inline bool Message::has_msg() const { - return msg_case() != MSG_NOT_SET; -} -inline void Message::clear_has_msg() { - _impl_._oneof_case_[0] = MSG_NOT_SET; -} -inline Message::MsgCase Message::msg_case() const { - return Message::MsgCase(_impl_._oneof_case_[0]); -} -#ifdef __GNUC__ -#pragma GCC diagnostic pop -#endif // __GNUC__ - -// @@protoc_insertion_point(namespace_scope) -} // namespace message -} // namespace dapi - - -// @@protoc_insertion_point(global_scope) - -#include "google/protobuf/port_undef.inc" - -#endif // message_2eproto_2epb_2eh diff --git a/Source/dapi/Item.h b/Source/dapi/Item.h index 2dbd26e53..63d9d0aea 100644 --- a/Source/dapi/Item.h +++ b/Source/dapi/Item.h @@ -1,5 +1,4 @@ #pragma once -#include #include "../items.h" @@ -18,7 +17,7 @@ struct ItemData { int _ix; int _iy; - BOOL _iIdentified; + uint32_t _iIdentified; char _iMagical; char _iName[64]; char _iIName[64]; @@ -66,7 +65,7 @@ struct ItemData { char _iMinStr; char _iMinMag; char _iMinDex; - BOOL _iStatFlag; + uint32_t _iStatFlag; int IDidx; }; } // namespace DAPI diff --git a/Source/dapi/Player.h b/Source/dapi/Player.h index 911dfc838..bbb07286a 100644 --- a/Source/dapi/Player.h +++ b/Source/dapi/Player.h @@ -21,9 +21,9 @@ struct PlayerData { char _pRSplType; char _pSplLvl[64]; - unsigned __int64 _pMemSpells; - unsigned __int64 _pAblSpells; - unsigned __int64 _pScrlSpells; + uint64_t _pMemSpells; + uint64_t _pAblSpells; + uint64_t _pScrlSpells; char _pName[32]; char _pClass; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 7aab6eda6..48c1e6f8c 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1,3 +1,5 @@ +#include + #include "Server.h" @@ -239,9 +241,9 @@ void Server::updateGameData() data->itemList[itemID]._iIdentified = item->_iIdentified; data->itemList[itemID]._iMagical = item->_iMagical; - strcpy_s(data->itemList[itemID]._iName, item->_iName); + strcpy(data->itemList[itemID]._iName, item->_iName); if (data->itemList[itemID]._iIdentified) { - strcpy_s(data->itemList[itemID]._iIName, item->_iIName); + strcpy(data->itemList[itemID]._iIName, item->_iIName); data->itemList[itemID]._iFlags = static_cast(item->_iFlags); data->itemList[itemID]._iPrePower = item->_iPrePower; @@ -267,7 +269,7 @@ void Server::updateGameData() data->itemList[itemID]._iLMinDam = item->_iLMinDam; data->itemList[itemID]._iLMaxDam = item->_iLMaxDam; } else { - strcpy_s(data->itemList[itemID]._iName, item->_iName); + strcpy(data->itemList[itemID]._iName, item->_iName); data->itemList[itemID]._iFlags = -1; data->itemList[itemID]._iPrePower = -1; @@ -330,11 +332,11 @@ void Server::updateGameData() data->itemList[itemID]._iIdentified = item->_iIdentified; data->itemList[itemID]._iMagical = item->_iMagical; - strcpy_s(data->itemList[itemID]._iName, item->_iName); + strcpy(data->itemList[itemID]._iName, item->_iName); if (data->itemList[itemID]._iIdentified) - strcpy_s(data->itemList[itemID]._iIName, item->_iIName); + strcpy(data->itemList[itemID]._iIName, item->_iIName); else - strcpy_s(data->itemList[itemID]._iName, item->_iName); + strcpy(data->itemList[itemID]._iName, item->_iName); data->itemList[itemID]._iFlags = -1; data->itemList[itemID]._iPrePower = -1; data->itemList[itemID]._iSufPower = -1; @@ -901,8 +903,8 @@ void Server::updateGameData() data->itemList[itemID]._iIdentified = -1; data->itemList[itemID]._iMagical = -1; - strcpy_s(data->itemList[itemID]._iName, ""); - strcpy_s(data->itemList[itemID]._iIName, ""); + strcpy(data->itemList[itemID]._iName, ""); + strcpy(data->itemList[itemID]._iIName, ""); data->itemList[itemID]._iFlags = -1; data->itemList[itemID]._iPrePower = -1; data->itemList[itemID]._iSufPower = -1; @@ -1052,7 +1054,7 @@ void Server::updateGameData() if (devilution::currlevel != 0) { for (auto &townerData : data->townerList) { - strcpy_s(townerData._tName, ""); + strcpy(townerData._tName, ""); townerData._tx = -1; townerData._ty = -1; } @@ -1077,12 +1079,12 @@ void Server::updateGameData() memcpy(data->townerList[townerID]._tName, devilution::Towners[i].name.data(), devilution::Towners[i].name.size()); data->townerList[townerID]._tName[devilution::Towners[i].name.size()] = '\0'; } - // strcpy_s(data->townerList[townerID]._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. + // strcpy(data->townerList[townerID]._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. } else { data->townerList[townerID]._ttype = static_cast(devilution::Towners[i]._ttype); data->townerList[townerID]._tx = -1; data->townerList[townerID]._ty = -1; - strcpy_s(data->townerList[townerID]._tName, ""); + strcpy(data->townerList[townerID]._tName, ""); } } } @@ -1237,7 +1239,7 @@ void Server::updateGameData() m->set_sy(-1); } }; - + if (devilution::Players[devilution::MyPlayerId].plrlevel != 0) { for (int i = 0; i < devilution::ActiveObjectCount; i++) { if (isOnScreen(devilution::Objects[devilution::ActiveObjects[i]].position.x, devilution::Objects[devilution::ActiveObjects[i]].position.y) && devilution::dObject[devilution::Objects[devilution::ActiveObjects[i]].position.x][devilution::Objects[devilution::ActiveObjects[i]].position.y] == devilution::ActiveObjects[i] + 1) { @@ -1458,7 +1460,7 @@ void Server::buyItem(int itemID) devilution::OldTextLine = devilution::CurrentTextLine; devilution::OldScrollPos = devilution::ScrollPos; devilution::OldActiveStore = devilution::ActiveStore; - + if (!devilution::PlayerCanAfford(devilution::WitchItems[idx]._iIvalue)) { devilution::StartStore(devilution::TalkID::NoMoney); @@ -2308,7 +2310,7 @@ void Server::cancelQText() if (!data->qtextflag) return; - devilution::qtextflag = FALSE; + devilution::qtextflag = false; data->qtextflag = false; devilution::stream_stop(); } diff --git a/vcpkg.json b/vcpkg.json index efd4a21dd..759e23cce 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -5,7 +5,8 @@ "fmt", "bzip2", "lua", - "protobuf" + "protobuf", + "sfml" ], "builtin-baseline": "533a5fda5c0646d1771345fb572e759283444d5f", "features": { From 57d7c4b3f71b824e98bfcf9e78105e18fdc8bda7 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Thu, 8 May 2025 22:03:35 -0400 Subject: [PATCH 03/32] SFML and ProtoClient Fixes Change to newest SFML and fix linkage, additionally fix the DAPIProtoClient to be SFML 3.0 compatible. --- Source/CMakeLists.txt | 4 +-- .../DAPIBackendCore/DAPIProtoClient.cpp | 28 +++++++++---------- 2 files changed, 16 insertions(+), 16 deletions(-) diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 38be7866b..37240ac49 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -822,6 +822,6 @@ include_directories("${PROTO_BINARY_DIR}/dapi/Backend/Messages") target_include_directories(libdevilutionx PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/DAPIBackendCore") -find_package(SFML 2.5 REQUIRED network system) +find_package(SFML COMPONENTS Network CONFIG REQUIRED) -target_link_libraries(libdevilutionx PUBLIC sfml-network sfml-system) +target_link_libraries(libdevilutionx PUBLIC SFML::Network) diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp index a084e485b..944a4631c 100644 --- a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp @@ -23,9 +23,9 @@ void DAPIProtoClient::checkForConnection() udpbound = true; } - auto sender = sf::IpAddress::Any; + std::optional sender = sf::IpAddress::Any; auto port = udpSocket.getLocalPort(); - if (udpSocket.receive(packet, sender, port) != sf::Socket::Done) + if (udpSocket.receive(packet, sender, port) != sf::Socket::Status::Done) return; auto size = packet.getDataSize(); @@ -47,10 +47,10 @@ void DAPIProtoClient::checkForConnection() size = reply->ByteSize(); std::unique_ptr buffer(new char[size]); - reply->SerializeToArray(&buffer[0], size); + reply->SerializeToArray(&buffer[0], static_cast(size)); packet.append(buffer.get(), size); - udpSocket.send(packet, sender, port); + udpSocket.send(packet, sender.value(), port); udpSocket.unbind(); udpbound = false; @@ -74,10 +74,10 @@ void DAPIProtoClient::lookForServer() broadcastMessage->SerializeToArray(&buffer[0], size); packet.append(buffer.get(), size); - sf::IpAddress server = sf::IpAddress::Broadcast; + std::optional server = sf::IpAddress::Broadcast; unsigned short port = 1024; - udpSocket.send(packet, server, port); + udpSocket.send(packet, server.value(), port); server = sf::IpAddress::Any; udpSocket.setBlocking(false); // Sleep to give backend a chance to send the packet. @@ -85,7 +85,7 @@ void DAPIProtoClient::lookForServer() using namespace std::chrono_literals; std::this_thread::sleep_for(2s); } - if (udpSocket.receive(packet, server, port) == sf::Socket::Done) { + if (udpSocket.receive(packet, server, port) == sf::Socket::Status::Done) { size = packet.getDataSize(); std::unique_ptr replyBuffer(new char[size]); memcpy(replyBuffer.get(), packet.getData(), size); @@ -98,8 +98,8 @@ void DAPIProtoClient::lookForServer() connectionPort = static_cast(currentMessage->initresponse().port()); - tcpSocket.connect(server, connectionPort); - if (tcpSocket.getRemoteAddress() == sf::IpAddress::None) + tcpSocket.connect(server.value(), connectionPort); + if (!tcpSocket.getRemoteAddress().has_value()) fprintf(stderr, "%s", "Connection failed.\n"); } } @@ -123,7 +123,7 @@ void DAPIProtoClient::transmitMessages() currentMessage->SerializeToArray(&buffer[0], size); packet.append(buffer.get(), size); } - if (tcpSocket.send(packet) != sf::Socket::Done) { + if (tcpSocket.send(packet) != sf::Socket::Status::Done) { // Error sending message. fprintf(stderr, "Failed to send a Message. Disconnecting.\n"); disconnect(); @@ -138,7 +138,7 @@ void DAPIProtoClient::transmitMessages() std::unique_ptr buffer(new char[size]); currentMessage->SerializeToArray(&buffer[0], size); packet.append(buffer.get(), size); - if (tcpSocket.send(packet) != sf::Socket::Done) { + if (tcpSocket.send(packet) != sf::Socket::Status::Done) { // Error sending EndOfQueue fprintf(stderr, "Failed to send end of queue message. Disconnecting.\n"); disconnect(); @@ -157,7 +157,7 @@ void DAPIProtoClient::receiveMessages() while (true) { packet.clear(); currentMessage = std::make_unique(); - if (tcpSocket.receive(packet) != sf::Socket::Done) { + if (tcpSocket.receive(packet) != sf::Socket::Status::Done) { fprintf(stderr, "Failed to receive message. Disconnecting.\n"); disconnect(); return; @@ -182,7 +182,7 @@ void DAPIProtoClient::disconnect() void DAPIProtoClient::initListen() { tcpListener.setBlocking(true); - while (tcpListener.listen(connectionPort) != sf::Socket::Done) + while (tcpListener.listen(connectionPort) != sf::Socket::Status::Done) connectionPort = static_cast(getRandomInteger(1025, 49151)); } @@ -205,7 +205,7 @@ std::unique_ptr DAPIProtoClient::getNextMessage() bool DAPIProtoClient::isConnected() const { - return tcpSocket.getRemoteAddress() != sf::IpAddress::None; + return tcpSocket.getRemoteAddress().has_value(); } int DAPIProtoClient::messageQueueSize() const From 8d5c7e867c4100e659989489fecf73b4c9cdf687 Mon Sep 17 00:00:00 2001 From: Anders Jenbo Date: Fri, 9 May 2025 04:06:48 +0200 Subject: [PATCH 04/32] Fix warnings --- .../DAPIBackendCore/DAPIProtoClient.cpp | 11 +- .../Backend/DAPIBackendCore/DAPIProtoClient.h | 2 - Source/dapi/DiabloStructs.h | 0 Source/dapi/GameData.h | 4 - Source/dapi/Item.h | 2 +- Source/dapi/Server.cpp | 139 ++++++++++-------- Source/dapi/Server.h | 4 +- 7 files changed, 84 insertions(+), 78 deletions(-) delete mode 100644 Source/dapi/DiabloStructs.h diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp index 944a4631c..a37fb6d63 100644 --- a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp @@ -44,7 +44,7 @@ void DAPIProtoClient::checkForConnection() initResponse->set_port(static_cast(connectionPort)); packet.clear(); - size = reply->ByteSize(); + size = reply->ByteSizeLong(); std::unique_ptr buffer(new char[size]); reply->SerializeToArray(&buffer[0], static_cast(size)); @@ -64,11 +64,10 @@ void DAPIProtoClient::lookForServer() return; sf::Packet packet; - bool skip = false; auto broadcastMessage = std::make_unique(); - auto initResponse = broadcastMessage->mutable_initbroadcast(); + broadcastMessage->mutable_initbroadcast(); - auto size = broadcastMessage->ByteSize(); + auto size = broadcastMessage->ByteSizeLong(); std::unique_ptr buffer(new char[size]); broadcastMessage->SerializeToArray(&buffer[0], size); @@ -117,7 +116,7 @@ void DAPIProtoClient::transmitMessages() packet.clear(); currentMessage = std::move(messageQueue.front()); messageQueue.pop_front(); - auto size = currentMessage->ByteSize(); + auto size = currentMessage->ByteSizeLong(); if (size > 0) { std::unique_ptr buffer(new char[size]); currentMessage->SerializeToArray(&buffer[0], size); @@ -134,7 +133,7 @@ void DAPIProtoClient::transmitMessages() currentMessage = std::make_unique(); currentMessage->mutable_endofqueue(); packet.clear(); - auto size = currentMessage->ByteSize(); + auto size = currentMessage->ByteSizeLong(); std::unique_ptr buffer(new char[size]); currentMessage->SerializeToArray(&buffer[0], size); packet.append(buffer.get(), size); diff --git a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h index fac6a87dd..8ba4fc82a 100644 --- a/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h +++ b/Source/dapi/Backend/DAPIBackendCore/DAPIProtoClient.h @@ -5,9 +5,7 @@ #include -#pragma warning(push, 0) #include "message.pb.h" -#pragma warning(pop) namespace DAPI { struct DAPIProtoClient { diff --git a/Source/dapi/DiabloStructs.h b/Source/dapi/DiabloStructs.h deleted file mode 100644 index e69de29bb..000000000 diff --git a/Source/dapi/GameData.h b/Source/dapi/GameData.h index 5fee30c4c..2dfe9391d 100644 --- a/Source/dapi/GameData.h +++ b/Source/dapi/GameData.h @@ -25,16 +25,12 @@ enum struct StoreOption { }; struct GameData { - int player; - char stextflag; - int pauseMode; bool menuOpen; int pcurs; bool chrflag; bool invflag; bool qtextflag; int currlevel; - bool setlevel; std::map playerList; std::vector itemList; diff --git a/Source/dapi/Item.h b/Source/dapi/Item.h index 63d9d0aea..87f7c4e24 100644 --- a/Source/dapi/Item.h +++ b/Source/dapi/Item.h @@ -11,7 +11,7 @@ struct ItemData { int ID; - int _iSeed; + uint32_t _iSeed; int _iCreateInfo; int _itype; int _ix; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 48c1e6f8c..a9e180674 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -117,7 +117,7 @@ void Server::processMessages() } else if (command.has_talk() && this->OKToAct()) { auto talkMessage = command.talk(); this->talk(talkMessage.targetx(), talkMessage.targety()); - } else if (command.has_option() && this->data->stextflag) { + } else if (command.has_option() && devilution::ActiveStore != devilution::TalkID::None) { auto option = command.option(); this->selectStoreOption(static_cast(command.option().option())); } else if (command.has_buyitem()) { @@ -411,19 +411,15 @@ void Server::updateGameData() auto message = std::make_unique(); auto update = message->mutable_frameupdate(); - data->player = devilution::MyPlayerId; - update->set_player(data->player); + update->set_player(devilution::MyPlayerId); - data->stextflag = static_cast(devilution::ActiveStore); - update->set_stextflag(data->stextflag); - data->pauseMode = devilution::PauseMode; - update->set_pausemode(data->pauseMode); + update->set_stextflag(static_cast(devilution::ActiveStore)); + update->set_pausemode(devilution::PauseMode); if (devilution::sgpCurrentMenu != nullptr) data->menuOpen = true; else data->menuOpen = false; - update->set_menuopen(data->menuOpen); - data->pcurs = devilution::pcurs; + update->set_menuopen(static_cast(data->menuOpen)); update->set_cursor(devilution::pcurs); data->chrflag = devilution::CharFlag; update->set_chrflag(devilution::CharFlag); @@ -436,7 +432,6 @@ void Server::updateGameData() else data->currlevel = static_cast(devilution::setlvlnum); update->set_currlevel(data->currlevel); - data->setlevel = static_cast(devilution::setlevel); update->set_setlevel(devilution::setlevel); if (devilution::qtextflag) { std::stringstream qtextss; @@ -454,11 +449,6 @@ void Server::updateGameData() update->set_gndifficulty(devilution::sgGameInitInfo.nDifficulty); - int range = 10; - if (devilution::MyPlayer->isWalking()) { - range = 11; - } - for (int x = 0; x < 112; x++) { for (int y = 0; y < 112; y++) { if (isOnScreen(x, y)) { @@ -554,7 +544,7 @@ void Server::updateGameData() data->groundItems.clear(); - for (int i = 0; i < 4; i++) { + for (size_t i = 0; i < 4; i++) { auto playerData = update->add_playerdata(); data->playerList[i].InvBody.clear(); @@ -562,13 +552,13 @@ void Server::updateGameData() data->playerList[i].pnum = i; playerData->set_pnum(i); - memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); - playerData->set__pname(data->playerList[i]._pName); - for (int j = 0; j < MAXINV; j++) data->playerList[i].InvList[j] = -1; - if (devilution::MyPlayerId == i) { + if (devilution::MyPlayerId == i && devilution::Players.size() >= i + 1) { + memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); + playerData->set__pname(data->playerList[i]._pName); + data->playerList[i]._pmode = devilution::Players[i]._pmode; data->playerList[i].plrlevel = devilution::Players[i].plrlevel; data->playerList[i]._px = devilution::Players[i].position.tile.x; @@ -621,8 +611,8 @@ void Server::updateGameData() continue; } - int itemID = static_cast(data->itemList.size()); - for (int k = 0; k < data->itemList.size(); k++) { + size_t itemID = data->itemList.size(); + for (size_t k = 0; k < data->itemList.size(); k++) { if (data->itemList[k].compare(devilution::Players[i].InvBody[j])) { itemID = k; break; @@ -637,8 +627,8 @@ void Server::updateGameData() for (int j = 0; j < MAXINV; j++) { auto index = devilution::Players[i].InvGrid[j]; if (index != 0) { - int itemID = static_cast(data->itemList.size()); - for (int k = 0; k < data->itemList.size(); k++) { + size_t itemID = data->itemList.size(); + for (size_t k = 0; k < data->itemList.size(); k++) { if (data->itemList[k].compare(devilution::Players[i].InvList[abs(index) - 1])) { itemID = k; break; @@ -661,8 +651,8 @@ void Server::updateGameData() continue; } - int itemID = static_cast(data->itemList.size()); - for (int k = 0; k < data->itemList.size(); k++) { + size_t itemID = data->itemList.size(); + for (size_t k = 0; k < data->itemList.size(); k++) { if (data->itemList[k].compare(devilution::Players[i].SpdList[j])) { itemID = k; break; @@ -676,8 +666,8 @@ void Server::updateGameData() if (devilution::pcurs < 12) data->playerList[i].HoldItem = -1; else { - int itemID = static_cast(data->itemList.size()); - for (int j = 0; j < data->itemList.size(); j++) { + size_t itemID = data->itemList.size(); + for (size_t j = 0; j < data->itemList.size(); j++) { if (data->itemList[j].compare(devilution::Players[i].HoldItem)) { itemID = j; break; @@ -697,7 +687,10 @@ void Server::updateGameData() data->playerList[i]._pIBonusAC = devilution::Players[i]._pIBonusAC; data->playerList[i]._pIBonusDamMod = devilution::Players[i]._pIBonusDamMod; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; - } else if (devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { + } else if (devilution::Players.size() >= i + 1 && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { + memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); + playerData->set__pname(data->playerList[i]._pName); + data->playerList[i]._pmode = devilution::Players[i]._pmode; data->playerList[i].plrlevel = devilution::Players[i].plrlevel; data->playerList[i]._px = devilution::Players[i].position.tile.x; @@ -761,6 +754,9 @@ void Server::updateGameData() data->playerList[i]._pIBonusDamMod = -1; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; } else { + memset(data->playerList[i]._pName, 0, 32); + playerData->set__pname(data->playerList[i]._pName); + data->playerList[i]._pmode = 0; data->playerList[i].plrlevel = -1; data->playerList[i]._px = -1; @@ -950,8 +946,8 @@ void Server::updateGameData() }; for (int i = 0; i < devilution::ActiveItemCount; i++) { - int itemID = static_cast(data->itemList.size()); - for (int j = 0; j < data->itemList.size(); j++) { + size_t itemID = static_cast(data->itemList.size()); + for (size_t j = 0; j < data->itemList.size(); j++) { if (data->itemList[j].compare(devilution::Items[devilution::ActiveItems[i]])) { itemID = j; break; @@ -1023,6 +1019,8 @@ void Server::updateGameData() currentItem = &devilution::BoyItem; shiftValue = true; break; + default: + break; } for (int i = 0; i < storeLoopMax; i++) { if (currentItem->_itype != devilution::ItemType::None) { @@ -1061,7 +1059,7 @@ void Server::updateGameData() } else { for (auto i = 0; i < NUM_TOWNERS; i++) { auto townerID = data->townerList.size(); - for (int j = 0; j < data->townerList.size(); j++) { + for (size_t j = 0; j < data->townerList.size(); j++) { if (data->townerList[j]._ttype == devilution::Towners[i]._ttype) { townerID = j; break; @@ -1158,7 +1156,7 @@ void Server::updateGameData() for (auto &itemID : data->groundItems) update->add_grounditemid(itemID); - for (int i = 0; i < devilution::ActiveMonsterCount; i++) { + for (size_t i = 0; i < devilution::ActiveMonsterCount; i++) { if (isOnScreen(devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.x, devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.y) && devilution::HasAnyOf(devilution::dFlags[devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.x][devilution::Monsters[devilution::ActiveMonsters[i]].position.tile.y], devilution::DungeonFlag::Lit) && !(devilution::Monsters[devilution::ActiveMonsters[i]].flags & 0x01)) { auto m = update->add_monsterdata(); m->set_index(devilution::ActiveMonsters[i]); @@ -1200,6 +1198,8 @@ void Server::updateGameData() case devilution::_object_id::OBJ_L3RDOOR: o->set_doorstate(ob._oVar4); break; + default: + break; } if (devilution::Players[devilution::MyPlayerId]._pClass == devilution::HeroClass::Rogue) o->set_trapped(ob._oTrapFlag); @@ -1214,7 +1214,6 @@ void Server::updateGameData() m->set_y(ms.position.tile.y); m->set_xvel(ms.position.velocity.deltaX); m->set_yvel(ms.position.velocity.deltaY); - bool addSource = false; switch (ms.sourceType()) { case devilution::MissileSource::Monster: if (isOnScreen(ms.sourceMonster()->position.tile.x, ms.sourceMonster()->position.tile.y)) { @@ -1273,8 +1272,8 @@ void Server::updateGameData() bool Server::isOnScreen(int x, int y) { bool returnValue = false; - int dx = data->playerList[data->player]._px - x; - int dy = data->playerList[data->player]._py - y; + int dx = data->playerList[devilution::MyPlayerId]._px - x; + int dy = data->playerList[devilution::MyPlayerId]._py - y; if (!devilution::CharFlag) { if (dy > 0) { if (dx < 1 && abs(dx) + abs(dy) < 11) @@ -1295,7 +1294,7 @@ bool Server::isOnScreen(int x, int y) bool Server::OKToAct() { - return !data->stextflag && data->pcurs == 1 && !data->qtextflag; + return devilution::ActiveStore == devilution::TalkID::None && devilution::pcurs == 1 && !data->qtextflag; } void Server::move(int x, int y) @@ -1318,15 +1317,14 @@ void Server::selectStoreOption(StoreOption option) { switch (option) { case StoreOption::TALK: - switch (devilution::ActiveStore) { - case devilution::TalkID::Witch: + if (devilution::ActiveStore == devilution::TalkID::Witch) { devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::OldTextLine = 12; devilution::TownerId = devilution::_talker_id::TOWN_WITCH; devilution::OldActiveStore = devilution::TalkID::Witch; devilution::StartStore(devilution::TalkID::Gossip); - break; } + break; case StoreOption::IDENTIFYANITEM: if (devilution::ActiveStore == devilution::TalkID::Storyteller) { devilution::PlaySFX(devilution::SfxID::MenuSelect); @@ -1346,6 +1344,8 @@ void Server::selectStoreOption(StoreOption option) case devilution::TalkID::Witch: devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::ActiveStore = devilution::TalkID::None; + default: + break; } break; case StoreOption::BUYITEMS: @@ -1358,6 +1358,8 @@ void Server::selectStoreOption(StoreOption option) devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::StartStore(devilution::TalkID::HealerBuy); break; + default: + break; } break; case StoreOption::BUYBASIC: @@ -1382,6 +1384,8 @@ void Server::selectStoreOption(StoreOption option) devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::StartStore(devilution::TalkID::WitchSell); break; + default: + break; } break; case StoreOption::REPAIR: @@ -1433,7 +1437,12 @@ void Server::selectStoreOption(StoreOption option) devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::StartStore(devilution::TalkID::Storyteller); break; + default: + break; } + break; + default: + break; } } @@ -1912,6 +1921,8 @@ void Server::increaseStat(CommandType commandType) case devilution::HeroClass::Sorcerer: maxValue = 45; break; + default: + break; } if (devilution::Players[devilution::MyPlayerId]._pBaseStr < maxValue) { devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDSTR, 1); @@ -1929,6 +1940,8 @@ void Server::increaseStat(CommandType commandType) case devilution::HeroClass::Sorcerer: maxValue = 250; break; + default: + break; } if (devilution::Players[devilution::MyPlayerId]._pBaseMag < maxValue) { devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDMAG, 1); @@ -1946,6 +1959,8 @@ void Server::increaseStat(CommandType commandType) case devilution::HeroClass::Sorcerer: maxValue = 85; break; + default: + break; } if (devilution::Players[devilution::MyPlayerId]._pBaseDex < maxValue) { devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDDEX, 1); @@ -1957,10 +1972,7 @@ void Server::increaseStat(CommandType commandType) case devilution::HeroClass::Warrior: maxValue = 100; break; - case devilution::HeroClass::Rogue: - maxValue = 80; - break; - case devilution::HeroClass::Sorcerer: + default: maxValue = 80; break; } @@ -1968,6 +1980,9 @@ void Server::increaseStat(CommandType commandType) devilution::NetSendCmdParam1(true, devilution::_cmd_id::CMD_ADDVIT, 1); devilution::Players[devilution::MyPlayerId]._pStatPts -= 1; } + break; + default: + break; } } @@ -1978,7 +1993,7 @@ void Server::getItem(int itemID) bool found = false; - for (auto i = 0; i < data->groundItems.size(); i++) { + for (size_t i = 0; i < data->groundItems.size(); i++) { if (data->groundItems[i] == itemID) found = true; if (found) @@ -2064,7 +2079,7 @@ void Server::toggleInventory() devilution::invflag = !devilution::invflag; } -void Server::putInCursor(int itemID) +void Server::putInCursor(size_t itemID) { if (!OKToAct()) return; @@ -2112,6 +2127,8 @@ void Server::putInCursor(int itemID) mx = devilution::InvRect[19].position.x + 1; my = devilution::InvRect[19].position.y - 1; break; + default: + break; } break; } @@ -2132,7 +2149,6 @@ void Server::putInCursor(int itemID) } } else { if (item.compare(devilution::Players[devilution::MyPlayerId].SpdList[i - 47]) && devilution::Players[devilution::MyPlayerId].SpdList[i - 47]._itype != devilution::ItemType::None) { - int index = 18 + i; mx = 210 + (i - 47) * 30; my = 370; break; @@ -2151,7 +2167,7 @@ void Server::putCursorItem(int location) if (!data->invflag) return; - if (12 <= data->pcurs && equipLocation <= EquipSlot::BELT8) { + if (12 <= devilution::pcurs && equipLocation <= EquipSlot::BELT8) { mx = 0; my = 0; switch (equipLocation) { @@ -2189,7 +2205,6 @@ void Server::putCursorItem(int location) mx = devilution::InvRect[index].position.x + 2; my = devilution::InvRect[index].position.y - 20; } else { - int index = 18 + location; mx = 210 + (location - 47) * 30; my = 370; } @@ -2204,13 +2219,13 @@ void Server::dropCursorItem() if (!isOnScreen(devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y)) return; - if (12 <= data->pcurs) { + if (12 <= devilution::pcurs) { devilution::NetSendCmdPItem(true, devilution::_cmd_id::CMD_PUTITEM, devilution::Point { devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y }, devilution::MyPlayer->HoldItem); devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); } } -void Server::useItem(int itemID) +void Server::useItem(size_t itemID) { if (!OKToAct()) return; @@ -2236,12 +2251,10 @@ void Server::useItem(int itemID) void Server::identifyStoreItem(int itemID) { - int id; - if (devilution::ActiveStore != devilution::TalkID::StorytellerIdentify) return; - id = -1; + int id = -1; for (int i = 0; i < 20; i++) { if (data->itemList[itemID].compare(devilution::PlayerItems[i])) { @@ -2265,7 +2278,7 @@ void Server::identifyStoreItem(int itemID) } else { devilution::Player &myPlayer = *devilution::MyPlayer; - int idx = devilution::PlayerItemIndexes[idx]; + int idx = devilution::PlayerItemIndexes[id]; if (idx < 0) { if (idx == -1) myPlayer.InvBody[devilution::INVLOC_HEAD]._iIdentified = true; @@ -2322,10 +2335,10 @@ void Server::setFPS(int newFPS) void Server::disarmTrap(int index) { - if (data->pcurs != devilution::cursor_id::CURSOR_DISARM) + if (devilution::pcurs != devilution::cursor_id::CURSOR_DISARM) return; - if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Rogue) + if (static_cast(data->playerList[devilution::MyPlayerId]._pClass) != devilution::HeroClass::Rogue) return; devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_DISARMXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }, index); @@ -2333,10 +2346,10 @@ void Server::disarmTrap(int index) void Server::skillRepair(int itemID) { - if (data->pcurs != devilution::cursor_id::CURSOR_REPAIR) + if (devilution::pcurs != devilution::cursor_id::CURSOR_REPAIR) return; - if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Warrior) + if (static_cast(data->playerList[devilution::MyPlayerId]._pClass) != devilution::HeroClass::Warrior) return; if (!data->invflag) @@ -2358,10 +2371,10 @@ void Server::skillRepair(int itemID) void Server::skillRecharge(int itemID) { - if (static_cast(data->pcurs) != devilution::cursor_id::CURSOR_RECHARGE) + if (devilution::pcurs != devilution::cursor_id::CURSOR_RECHARGE) return; - if (static_cast(data->playerList[data->player]._pClass) != devilution::HeroClass::Sorcerer) + if (static_cast(data->playerList[devilution::MyPlayerId]._pClass) != devilution::HeroClass::Sorcerer) return; for (int i = 0; i < 7; i++) { @@ -2409,7 +2422,7 @@ void Server::quit() void Server::clearCursor() { - if (devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_REPAIR) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_DISARM) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_RECHARGE) || devilution::pcurs == static_cast(devilution::cursor_id::CURSOR_IDENTIFY)) + if (devilution::pcurs == devilution::cursor_id::CURSOR_REPAIR || devilution::pcurs == devilution::cursor_id::CURSOR_DISARM || devilution::pcurs == devilution::cursor_id::CURSOR_RECHARGE || devilution::pcurs == devilution::cursor_id::CURSOR_IDENTIFY) devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); return; @@ -2417,7 +2430,7 @@ void Server::clearCursor() void Server::identifyItem(int itemID) { - if (static_cast(data->pcurs) != devilution::cursor_id::CURSOR_IDENTIFY) + if (devilution::pcurs != devilution::cursor_id::CURSOR_IDENTIFY) return; if (!data->invflag) diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h index 947ca1003..13f7a4031 100644 --- a/Source/dapi/Server.h +++ b/Source/dapi/Server.h @@ -226,10 +226,10 @@ private: void setSpell(int spellID, devilution::SpellType spellType); void castSpell(int index); void toggleInventory(); - void putInCursor(int itemID); + void putInCursor(size_t itemID); void putCursorItem(int location); void dropCursorItem(); - void useItem(int itemID); + void useItem(size_t itemID); void identifyStoreItem(int itemID); void castSpell(int x, int y); void cancelQText(); From c26aaddfab26146cde3a967a30fcf0aaeededa17 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 9 May 2025 00:31:40 -0400 Subject: [PATCH 05/32] Fix Monster Selection Loop and DAPI Griswold Loop crashes (in debug build only somehow?) for selecting monster types when playing Diablo mode due to less monster types being available. Fixes Griswold data not being sent client side due to extra blank entries in Towners struct. --- Source/dapi/Server.cpp | 4 ++-- Source/monster.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index a9e180674..f88d27bd2 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -544,7 +544,7 @@ void Server::updateGameData() data->groundItems.clear(); - for (size_t i = 0; i < 4; i++) { + for (size_t i = 0; i < devilution::gbActivePlayers; i++) { auto playerData = update->add_playerdata(); data->playerList[i].InvBody.clear(); @@ -1057,7 +1057,7 @@ void Server::updateGameData() townerData._ty = -1; } } else { - for (auto i = 0; i < NUM_TOWNERS; i++) { + for (auto i = 0; devilution::gbIsHellfire ? i < NUM_TOWNERS : i < 10; i++) { auto townerID = data->townerList.size(); for (size_t j = 0; j < data->townerList.size(); j++) { if (data->townerList[j]._ttype == devilution::Towners[i]._ttype) { diff --git a/Source/monster.cpp b/Source/monster.cpp index f003d66d7..6a4078cb1 100644 --- a/Source/monster.cpp +++ b/Source/monster.cpp @@ -3338,7 +3338,7 @@ tl::expected GetLevelMTypes() _monster_id typelist[MaxMonsters]; int nt = 0; - for (int i = MT_NZOMBIE; i < NUM_MTYPES; i++) { + for (int i = MT_NZOMBIE; i < MonstersData.size(); i++) { if (!IsMonsterAvalible(MonstersData[i])) continue; From 882b3e8e74e13793ca0056fc57eb8a46c96a172b Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 9 May 2025 10:27:29 -0400 Subject: [PATCH 06/32] Fix Inventory Functions Fixes compatibility for the inventory manipulation functions for DevilutionX. --- Source/dapi/Server.cpp | 79 ++++++++++++++++++++---------------------- 1 file changed, 37 insertions(+), 42 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index f88d27bd2..1bee6e2cb 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -2087,7 +2087,7 @@ void Server::putInCursor(size_t itemID) if (data->itemList.size() <= itemID) return; - auto item = data->itemList[itemID]; + auto &item = data->itemList[itemID]; int mx, my; mx = 0; @@ -2098,34 +2098,35 @@ void Server::putInCursor(size_t itemID) if (!devilution::invflag) return; + // Switch statement is left here because left and right ring are reversed in DevilutionX switch (static_cast(i)) { case EquipSlot::HEAD: - mx = devilution::InvRect[0].position.x + 1; - my = devilution::InvRect[0].position.y - 1; + mx = devilution::InvRect[0].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[0].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::LEFTRING: - mx = devilution::InvRect[4].position.x + 1; - my = devilution::InvRect[4].position.y - 1; + mx = devilution::InvRect[1].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[1].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::RIGHTRING: - mx = devilution::InvRect[5].position.x + 1; - my = devilution::InvRect[5].position.y - 1; + mx = devilution::InvRect[2].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[2].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::AMULET: - mx = devilution::InvRect[6].position.x + 1; - my = devilution::InvRect[6].position.y - 1; + mx = devilution::InvRect[3].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[3].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::LEFTHAND: - mx = devilution::InvRect[7].position.x + 1; - my = devilution::InvRect[7].position.y - 1; + mx = devilution::InvRect[4].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[4].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::RIGHTHAND: - mx = devilution::InvRect[13].position.x + 1; - my = devilution::InvRect[13].position.y - 1; + mx = devilution::InvRect[5].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[5].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::BODY: - mx = devilution::InvRect[19].position.x + 1; - my = devilution::InvRect[19].position.y - 1; + mx = devilution::InvRect[6].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[6].position.y + 1 + devilution::GetRightPanel().position.y; break; default: break; @@ -2139,9 +2140,9 @@ void Server::putInCursor(size_t itemID) for (int rect_index = 0; rect_index < 40; rect_index++) { if (devilution::Players[devilution::MyPlayerId].InvGrid[rect_index] == i - 6) { - int index = rect_index + 25; - mx = devilution::InvRect[index].position.x + 1; - my = devilution::InvRect[index].position.y - 1; + int index = rect_index + 7; + mx = devilution::InvRect[index].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[index].position.y + 1 + devilution::GetRightPanel().position.y; break; } } @@ -2149,8 +2150,8 @@ void Server::putInCursor(size_t itemID) } } else { if (item.compare(devilution::Players[devilution::MyPlayerId].SpdList[i - 47]) && devilution::Players[devilution::MyPlayerId].SpdList[i - 47]._itype != devilution::ItemType::None) { - mx = 210 + (i - 47) * 30; - my = 370; + mx = devilution::InvRect[i].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[i].position.y + 1 + devilution::GetRightPanel().position.y; break; } } @@ -2172,42 +2173,36 @@ void Server::putCursorItem(int location) my = 0; switch (equipLocation) { case EquipSlot::HEAD: - mx = devilution::InvRect[0].position.x + 1; - my = devilution::InvRect[0].position.y - 1; + mx = devilution::InvRect[0].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[0].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::LEFTRING: - mx = devilution::InvRect[4].position.x + 2; - my = devilution::InvRect[4].position.y - 20; + mx = devilution::InvRect[1].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[1].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::RIGHTRING: - mx = devilution::InvRect[5].position.x + 2; - my = devilution::InvRect[5].position.y - 20; + mx = devilution::InvRect[2].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[2].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::AMULET: - mx = devilution::InvRect[6].position.x + 2; - my = devilution::InvRect[6].position.y - 20; + mx = devilution::InvRect[3].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[3].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::LEFTHAND: - mx = devilution::InvRect[7].position.x + 1; - my = devilution::InvRect[7].position.y - 1; + mx = devilution::InvRect[4].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[4].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::RIGHTHAND: - mx = devilution::InvRect[13].position.x + 1; - my = devilution::InvRect[13].position.y - 1; + mx = devilution::InvRect[5].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[5].position.y + 1 + devilution::GetRightPanel().position.y; break; case EquipSlot::BODY: - mx = devilution::InvRect[19].position.x + 1; - my = devilution::InvRect[19].position.y - 1; + mx = devilution::InvRect[6].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[6].position.y + 1 + devilution::GetRightPanel().position.y; break; default: - if (equipLocation < EquipSlot::BELT1) { - int index = 18 + location; - mx = devilution::InvRect[index].position.x + 2; - my = devilution::InvRect[index].position.y - 20; - } else { - mx = 210 + (location - 47) * 30; - my = 370; - } + mx = devilution::InvRect[static_cast(equipLocation)].position.x + 1 + devilution::GetRightPanel().position.x; + my = devilution::InvRect[static_cast(equipLocation)].position.y + 1 + devilution::GetRightPanel().position.y; break; } devilution::CheckInvPaste(*devilution::MyPlayer, devilution::Point { mx, my }); From 07a9e24fc305041065765a1084c28e414b26f057 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 9 May 2025 11:47:42 -0400 Subject: [PATCH 07/32] FIx Menu Actions This allows DAPI to interact with the menu in game. --- Source/dapi/Server.cpp | 1 + Source/diablo.cpp | 1 + 2 files changed, 2 insertions(+) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 1bee6e2cb..ce8464da6 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -2401,6 +2401,7 @@ void Server::saveGame() if (devilution::gbIsMultiplayer || !devilution::gmenu_is_active()) return; + devilution::gmenu_presskeys(SDLK_DOWN); devilution::gmenu_presskeys(SDLK_KP_ENTER); return; } diff --git a/Source/diablo.cpp b/Source/diablo.cpp index e46c9ff22..fef2138f3 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -1459,6 +1459,7 @@ void UpdateMonsterLights() void GameLogic() { if (!ProcessInput()) { + dapiServer.update(); // For game menu commands return; } dapiServer.update(); From 09c7382f54db16f15de3f69e9fe406b291209b89 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 9 May 2025 14:33:29 -0400 Subject: [PATCH 08/32] Translate interface_mode Frontend uses the custom defined windows message values that 1.09 uses internally. This translates the equivalent DevilutionX messages back to the expected values. --- Source/dapi/Server.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index ce8464da6..bcba8d276 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -468,7 +468,9 @@ void Server::updateGameData() trigger->set_lvl(devilution::trigs[i]._tlvl); trigger->set_x(devilution::trigs[i].position.x); trigger->set_y(devilution::trigs[i].position.y); - trigger->set_type(devilution::trigs[i]._tmsg); + // Adding 0x402 to the message stored in the trigger to translate to what the front end expects. + // The front end uses what Diablo 1.09 uses internally. + trigger->set_type(static_cast(devilution::trigs[i]._tmsg) + 0x402); } } From 3fcb9081d7910c406c152e07343d6d29c4f9a59d Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 9 May 2025 17:15:09 -0400 Subject: [PATCH 09/32] Fix Command Send Changes Fixes CMD_OPOBJXY and CMD_DISARMXY which are sent with a different NetSend command in DevilutionX. --- Source/dapi/Server.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index bcba8d276..c51277f96 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1881,7 +1881,7 @@ void Server::operateObject(int index) if (!found) return; - devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_OPOBJXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }, index); + devilution::NetSendCmdLoc(devilution::MyPlayerId, true, devilution::_cmd_id::CMD_OPOBJXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }); } void Server::useBeltItem(int slot) @@ -2338,7 +2338,7 @@ void Server::disarmTrap(int index) if (static_cast(data->playerList[devilution::MyPlayerId]._pClass) != devilution::HeroClass::Rogue) return; - devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_DISARMXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }, index); + devilution::NetSendCmdLoc(devilution::MyPlayerId, true, devilution::_cmd_id::CMD_DISARMXY, devilution::Point { devilution::Objects[index].position.x, devilution::Objects[index].position.y }); } void Server::skillRepair(int itemID) From c423be629dca7357eca32500efdfbef409d39bfb Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sat, 10 May 2025 18:46:42 -0400 Subject: [PATCH 10/32] Refactor and Fix Inv Paste and Witch Sell Fixes Inventory pasting and refactors it based on how DevilutionX works internally. Also fixes Adria's sell window storing wrong OldActiveStore. --- Source/dapi/Server.cpp | 62 ++++++++++++++---------------------------- 1 file changed, 20 insertions(+), 42 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index c51277f96..95e627650 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1689,7 +1689,7 @@ void Server::sellItem(int itemID) devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::OldTextLine = devilution::CurrentTextLine; - devilution::OldActiveStore = devilution::TalkID::SmithSell; + devilution::OldActiveStore = devilution::ActiveStore; devilution::OldScrollPos = devilution::ScrollPos; if (!devilution::StoreGoldFit(devilution::PlayerItems[idx])) { @@ -2152,8 +2152,8 @@ void Server::putInCursor(size_t itemID) } } else { if (item.compare(devilution::Players[devilution::MyPlayerId].SpdList[i - 47]) && devilution::Players[devilution::MyPlayerId].SpdList[i - 47]._itype != devilution::ItemType::None) { - mx = devilution::InvRect[i].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[i].position.y + 1 + devilution::GetRightPanel().position.y; + mx = devilution::InvRect[i].position.x + 1 + devilution::GetMainPanel().position.x; + my = devilution::InvRect[i].position.y + 1 + devilution::GetMainPanel().position.y; break; } } @@ -2164,51 +2164,29 @@ void Server::putInCursor(size_t itemID) void Server::putCursorItem(int location) { - int mx, my; EquipSlot equipLocation = static_cast(location); if (!data->invflag) return; - if (12 <= devilution::pcurs && equipLocation <= EquipSlot::BELT8) { - mx = 0; - my = 0; - switch (equipLocation) { - case EquipSlot::HEAD: - mx = devilution::InvRect[0].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[0].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::LEFTRING: - mx = devilution::InvRect[1].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[1].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::RIGHTRING: - mx = devilution::InvRect[2].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[2].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::AMULET: - mx = devilution::InvRect[3].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[3].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::LEFTHAND: - mx = devilution::InvRect[4].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[4].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::RIGHTHAND: - mx = devilution::InvRect[5].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[5].position.y + 1 + devilution::GetRightPanel().position.y; - break; - case EquipSlot::BODY: - mx = devilution::InvRect[6].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[6].position.y + 1 + devilution::GetRightPanel().position.y; - break; - default: - mx = devilution::InvRect[static_cast(equipLocation)].position.x + 1 + devilution::GetRightPanel().position.x; - my = devilution::InvRect[static_cast(equipLocation)].position.y + 1 + devilution::GetRightPanel().position.y; - break; - } - devilution::CheckInvPaste(*devilution::MyPlayer, devilution::Point { mx, my }); + int invRectIndex = location; + devilution::Point cursorPosition; + devilution::Displacement panelAdjust; + if (equipLocation == EquipSlot::LEFTRING) { + invRectIndex = 1; + } else if (equipLocation == EquipSlot::RIGHTRING) { + invRectIndex = 2; } + cursorPosition = devilution::InvRect[invRectIndex].position + devilution::Displacement { 1, 1 }; + + if (equipLocation < EquipSlot::BELT1) { + panelAdjust = devilution::GetRightPanel().position - devilution::Point { 0, 0 }; + } else { + panelAdjust = devilution::GetMainPanel().position - devilution::Point { 0, 0 }; + } + + cursorPosition += panelAdjust; + devilution::CheckInvPaste(*devilution::MyPlayer, cursorPosition); } void Server::dropCursorItem() From 550c3e8a624a8c72ed976a1491a9b2d514921dba Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sat, 10 May 2025 19:05:39 -0400 Subject: [PATCH 11/32] Add Backend Awareness Adds an enum and to the frameupdate message so the frontend can know what backend it is attached to. Needed since DevilutionX has some differences such as TileIDs and Pepin auto healing, etc. --- Source/dapi/Backend/Messages/game.proto | 27 +++++++++++++------------ Source/dapi/Server.cpp | 2 ++ Source/dapi/Server.h | 5 +++++ 3 files changed, 21 insertions(+), 13 deletions(-) diff --git a/Source/dapi/Backend/Messages/game.proto b/Source/dapi/Backend/Messages/game.proto index a42630d28..df7e58a26 100644 --- a/Source/dapi/Backend/Messages/game.proto +++ b/Source/dapi/Backend/Messages/game.proto @@ -19,18 +19,19 @@ message FrameUpdate { uint32 fps = 12; uint32 gameMode = 13; uint32 gnDifficulty = 14; + uint32 connectedTo = 15; - repeated dapi.data.TileData dPiece = 15; - repeated dapi.data.PlayerData playerData = 16; - repeated dapi.data.ItemData itemData = 17; - repeated uint32 groundItemID = 18; - repeated dapi.data.TownerData townerData = 19; - repeated uint32 storeOption = 20; - repeated uint32 storeItems = 21; - repeated dapi.data.TriggerData triggerData = 22; - repeated dapi.data.MonsterData monsterData = 23; - repeated dapi.data.ObjectData objectData = 24; - repeated dapi.data.MissileData missileData = 25; - repeated dapi.data.PortalData portalData = 26; - repeated dapi.data.QuestData questData = 27; + repeated dapi.data.TileData dPiece = 16; + repeated dapi.data.PlayerData playerData = 17; + repeated dapi.data.ItemData itemData = 18; + repeated uint32 groundItemID = 19; + repeated dapi.data.TownerData townerData = 20; + repeated uint32 storeOption = 21; + repeated uint32 storeItems = 22; + repeated dapi.data.TriggerData triggerData = 23; + repeated dapi.data.MonsterData monsterData = 24; + repeated dapi.data.ObjectData objectData = 25; + repeated dapi.data.MissileData missileData = 26; + repeated dapi.data.PortalData portalData = 27; + repeated dapi.data.QuestData questData = 28; } diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 95e627650..178e9f211 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -411,6 +411,8 @@ void Server::updateGameData() auto message = std::make_unique(); auto update = message->mutable_frameupdate(); + update->set_connectedto(1); + update->set_player(devilution::MyPlayerId); update->set_stextflag(static_cast(devilution::ActiveStore)); diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h index 13f7a4031..69f69052f 100644 --- a/Source/dapi/Server.h +++ b/Source/dapi/Server.h @@ -191,6 +191,11 @@ enum struct EquipSlot { BELT8 = 54 }; +enum struct Backend { + Vanilla109, + DevilutionX +}; + struct Server { Server(); From 81af756109e844df51f6e4fe00cf9c796937872a Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sun, 11 May 2025 09:43:31 -0400 Subject: [PATCH 12/32] Fix Placing Items From Cursor This makes placing items from cursor functional as it fully accounts for how DevilutionX handles item graphic cursors (the cursor point is considered in the middle instead of top left) --- Source/dapi/Server.cpp | 20 ++++++++++++++------ 1 file changed, 14 insertions(+), 6 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 178e9f211..2fde96eda 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -2173,21 +2173,29 @@ void Server::putCursorItem(int location) int invRectIndex = location; devilution::Point cursorPosition; - devilution::Displacement panelAdjust; + devilution::Displacement panelOffset; + devilution::Displacement hotPixelCellOffset; if (equipLocation == EquipSlot::LEFTRING) { invRectIndex = 1; } else if (equipLocation == EquipSlot::RIGHTRING) { invRectIndex = 2; } - cursorPosition = devilution::InvRect[invRectIndex].position + devilution::Displacement { 1, 1 }; - if (equipLocation < EquipSlot::BELT1) { - panelAdjust = devilution::GetRightPanel().position - devilution::Point { 0, 0 }; + panelOffset = devilution::GetRightPanel().position - devilution::Point { 0, 0 }; + } else { + panelOffset = devilution::GetMainPanel().position - devilution::Point { 0, 0 }; + } + if (EquipSlot::INV1 <= equipLocation && equipLocation <= EquipSlot::INV40) { + const devilution::Size itemSize = devilution::GetInventorySize(devilution::MyPlayer->HoldItem); + if (itemSize.height <= 1 && itemSize.width <= 1) { + hotPixelCellOffset = devilution::Displacement { 1, 1 }; + } + hotPixelCellOffset = { (itemSize.width - 1) / 2 + 19, (itemSize.height - 1) / 2 + 19}; } else { - panelAdjust = devilution::GetMainPanel().position - devilution::Point { 0, 0 }; + hotPixelCellOffset = devilution::Displacement { 1, 1 }; } - cursorPosition += panelAdjust; + cursorPosition = devilution::InvRect[invRectIndex].position + panelOffset + hotPixelCellOffset; devilution::CheckInvPaste(*devilution::MyPlayer, cursorPosition); } From 3c3c3028d985d959b6ed956f71a92d1814b87e89 Mon Sep 17 00:00:00 2001 From: staphen Date: Sun, 11 May 2025 18:15:29 -0400 Subject: [PATCH 13/32] Enable compiling SFML from source --- 3rdParty/sfml/CMakeLists.txt | 12 ++++++++++++ CMake/Dependencies.cmake | 5 +++++ Source/CMakeLists.txt | 5 +---- 3 files changed, 18 insertions(+), 4 deletions(-) create mode 100644 3rdParty/sfml/CMakeLists.txt diff --git a/3rdParty/sfml/CMakeLists.txt b/3rdParty/sfml/CMakeLists.txt new file mode 100644 index 000000000..0129477cd --- /dev/null +++ b/3rdParty/sfml/CMakeLists.txt @@ -0,0 +1,12 @@ +include(functions/FetchContent_ExcludeFromAll_backport) + +set(SFML_BUILD_WINDOW OFF) +set(SFML_BUILD_GRAPHICS OFF) +set(SFML_BUILD_AUDIO OFF) + +include(FetchContent) +FetchContent_Declare_ExcludeFromAll(sfml + GIT_REPOSITORY https://github.com/SFML/SFML + GIT_TAG 016bea9491ccafc3529019fe1d403885a8b3a6ae +) +FetchContent_MakeAvailable_ExcludeFromAll(sfml) \ No newline at end of file diff --git a/CMake/Dependencies.cmake b/CMake/Dependencies.cmake index d99355366..030781d8c 100644 --- a/CMake/Dependencies.cmake +++ b/CMake/Dependencies.cmake @@ -275,3 +275,8 @@ if(GPERF) find_package(Gperftools REQUIRED) message("INFO: ${GPERFTOOLS_LIBRARIES}") endif() + +find_package(SFML 3.0 COMPONENTS Network CONFIG QUIET) +if(NOT SFML_FOUND) + add_subdirectory(3rdParty/sfml) +endif() diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 37240ac49..ae263a5cd 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -677,6 +677,7 @@ target_link_dependencies(libdevilutionx PUBLIC libsmackerdec ${LUA_LIBRARIES} sol2::sol2 + SFML::Network tl unordered_dense::unordered_dense libdevilutionx_assets @@ -821,7 +822,3 @@ target_include_directories(libdevilutionx PUBLIC "$ Date: Sun, 11 May 2025 20:47:05 -0400 Subject: [PATCH 14/32] Prevent Improper Store Usage Store options are built even if quest test is being displayed, so this prevents a DAPI AI from using a store while a quest text is up. --- Source/dapi/Server.cpp | 9 ++++++++- Source/diablo.cpp | 3 ++- 2 files changed, 10 insertions(+), 2 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 2fde96eda..90e5f2e21 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -494,7 +494,9 @@ void Server::updateGameData() } data->storeList.clear(); - if (devilution::ActiveStore != devilution::TalkID::None) { + // Check for qtextflag added for DevilutionX so that store options are not transmitted + // while qtext is up. + if (!devilution::qtextflag && devilution::ActiveStore != devilution::TalkID::None) { for (int i = 0; i < 24; i++) { if (devilution::TextLine[i].isSelectable()) { if (!strcmp(devilution::TextLine[i].text.c_str(), "Talk to Cain") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Farnham") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Pepin") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Gillian") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Ogden") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Griswold") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Adria") || !strcmp(devilution::TextLine[i].text.c_str(), "Talk to Wirt")) @@ -1319,6 +1321,11 @@ void Server::talk(int x, int y) void Server::selectStoreOption(StoreOption option) { + // Need to check for qtextflag in DevilutionX, for some reason we can access stores when + // the shop keeper is giving us quest text. Doesn't happen in 1.09. + if (devilution::qtextflag) + return; + switch (option) { case StoreOption::TALK: if (devilution::ActiveStore == devilution::TalkID::Witch) { diff --git a/Source/diablo.cpp b/Source/diablo.cpp index fef2138f3..3377380c4 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -1459,7 +1459,8 @@ void UpdateMonsterLights() void GameLogic() { if (!ProcessInput()) { - dapiServer.update(); // For game menu commands + if (gmenu_is_active()) + dapiServer.update(); // For game menu commands return; } dapiServer.update(); From a3509e11e2bbce31e6fef099d184681208fe56a0 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Mon, 12 May 2025 07:59:56 -0400 Subject: [PATCH 15/32] Fix Towners Fix towners to that cows don't get squished into one entity. --- Source/dapi/GameData.h | 2 +- Source/dapi/Server.cpp | 39 ++++++++++++++++----------------------- 2 files changed, 17 insertions(+), 24 deletions(-) diff --git a/Source/dapi/GameData.h b/Source/dapi/GameData.h index 2dfe9391d..0edd16505 100644 --- a/Source/dapi/GameData.h +++ b/Source/dapi/GameData.h @@ -35,7 +35,7 @@ struct GameData { std::map playerList; std::vector itemList; std::vector groundItems; - std::vector townerList; + std::map townerList; std::vector storeList; std::vector storeItems; std::vector triggerList; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 90e5f2e21..d2f41fd32 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1057,43 +1057,36 @@ void Server::updateGameData() } if (devilution::currlevel != 0) { - for (auto &townerData : data->townerList) { + for (auto &[_, townerData] : data->townerList) { strcpy(townerData._tName, ""); townerData._tx = -1; townerData._ty = -1; } } else { - for (auto i = 0; devilution::gbIsHellfire ? i < NUM_TOWNERS : i < 10; i++) { - auto townerID = data->townerList.size(); - for (size_t j = 0; j < data->townerList.size(); j++) { - if (data->townerList[j]._ttype == devilution::Towners[i]._ttype) { - townerID = j; - break; - } - } - if (townerID == data->townerList.size()) - data->townerList.push_back(TownerData {}); - data->townerList[townerID].ID = static_cast(townerID); + for (auto i = 0; devilution::gbIsHellfire ? i < NUM_TOWNERS : i < 12; i++) { + auto townerID = i; + auto &towner = data->townerList[townerID]; + towner.ID = static_cast(townerID); if (isOnScreen(devilution::Towners[i].position.x, devilution::Towners[i].position.y)) { - data->townerList[townerID]._ttype = devilution::Towners[i]._ttype; - data->townerList[townerID]._tx = devilution::Towners[i].position.x; - data->townerList[townerID]._ty = devilution::Towners[i].position.y; + towner._ttype = devilution::Towners[i]._ttype; + towner._tx = devilution::Towners[i].position.x; + towner._ty = devilution::Towners[i].position.y; // might rework this and just change the type in data. if (devilution::Towners[i].name.size() < 31) { - memcpy(data->townerList[townerID]._tName, devilution::Towners[i].name.data(), devilution::Towners[i].name.size()); - data->townerList[townerID]._tName[devilution::Towners[i].name.size()] = '\0'; + memcpy(towner._tName, devilution::Towners[i].name.data(), devilution::Towners[i].name.size()); + towner._tName[devilution::Towners[i].name.size()] = '\0'; } - // strcpy(data->townerList[townerID]._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. + // strcpy(towner._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. } else { - data->townerList[townerID]._ttype = static_cast(devilution::Towners[i]._ttype); - data->townerList[townerID]._tx = -1; - data->townerList[townerID]._ty = -1; - strcpy(data->townerList[townerID]._tName, ""); + towner._ttype = static_cast(devilution::Towners[i]._ttype); + towner._tx = -1; + towner._ty = -1; + strcpy(towner._tName, ""); } } } - for (auto &townie : data->townerList) { + for (auto &[_, townie] : data->townerList) { auto townerData = update->add_townerdata(); townerData->set_id(townie.ID); if (townie._tx != -1) From 5a0d215601410817b0fcf4eb275be66eab9a8a22 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Tue, 13 May 2025 00:25:35 -0400 Subject: [PATCH 16/32] Monster Name and Witch Fix Fixes the Monster Name passed to client and fixes buying items from Adria. --- Source/dapi/Server.cpp | 9 +++++---- 1 file changed, 5 insertions(+), 4 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index d2f41fd32..5aca4f425 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1078,7 +1078,7 @@ void Server::updateGameData() } // strcpy(towner._tName, devilution::Towners[i].name); old code but with devilution subbed in for reference. } else { - towner._ttype = static_cast(devilution::Towners[i]._ttype); + towner._ttype = devilution::Towners[i]._ttype; towner._tx = -1; towner._ty = -1; strcpy(towner._tName, ""); @@ -1164,9 +1164,10 @@ void Server::updateGameData() m->set_futx(devilution::Monsters[devilution::ActiveMonsters[i]].position.future.x); m->set_futy(devilution::Monsters[devilution::ActiveMonsters[i]].position.future.y); m->set_type(devilution::Monsters[devilution::ActiveMonsters[i]].type().type); - m->set_name(devilution::Monsters[devilution::ActiveMonsters[i]].data().name.c_str()); + std::string monsterName = std::string(devilution::Monsters[devilution::ActiveMonsters[i]].name()); + m->set_name(monsterName.c_str()); m->set_mode(static_cast(devilution::Monsters[devilution::ActiveMonsters[i]].mode)); - m->set_unique(static_cast(devilution::Monsters[devilution::ActiveMonsters[i]].isUnique())); + m->set_unique(devilution::Monsters[devilution::ActiveMonsters[i]].isUnique()); } } @@ -1482,7 +1483,7 @@ void Server::buyItem(int itemID) if (idx < 3) devilution::WitchItems[idx]._iSeed = devilution::AdvanceRndSeed(); - devilution::TakePlrsMoney(devilution::Players[devilution::MyPlayerId].HoldItem._iIvalue); + devilution::TakePlrsMoney(devilution::WitchItems[idx]._iIvalue); if (idx >= 3) { From 235783fb0c3720945b4c8ef139de886da9ee48d6 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Tue, 13 May 2025 22:23:57 -0400 Subject: [PATCH 17/32] Fix Quest Text Fix quest text by adding a space between the line breaks. --- Source/dapi/Server.cpp | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 5aca4f425..a36feddce 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -437,8 +437,11 @@ void Server::updateGameData() update->set_setlevel(devilution::setlevel); if (devilution::qtextflag) { std::stringstream qtextss; - for (auto &line : devilution::TextLines) + for (auto &line : devilution::TextLines) { + if (qtextss.str().size()) + qtextss << " "; qtextss << line; + } update->set_qtext(qtextss.str().c_str()); } else From 2a1a0360218cfc90700767584fba2484296cc163 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Tue, 13 May 2025 22:27:35 -0400 Subject: [PATCH 18/32] Fix Repair Logic Fix issue where magical items can have repair cost under 1 gold, and thus not be eligible for repair. --- Source/dapi/Server.cpp | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index a36feddce..ab904253e 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -995,15 +995,21 @@ void Server::updateGameData() devilution::Item *currentItem; bool useiValue = false; bool shiftValue = false; + bool checkRepairPrice = false; switch (devilution::ActiveStore) { case devilution::TalkID::StorytellerIdentify: case devilution::TalkID::WitchSell: case devilution::TalkID::WitchRecharge: case devilution::TalkID::SmithSell: + storeLoopMax = 48; + currentItem = &devilution::PlayerItems[0]; + useiValue = true; + break; case devilution::TalkID::SmithRepair: storeLoopMax = 48; currentItem = &devilution::PlayerItems[0]; useiValue = true; + checkRepairPrice = true; break; case devilution::TalkID::WitchBuy: storeLoopMax = devilution::NumWitchItemsHf; @@ -1033,8 +1039,19 @@ void Server::updateGameData() } for (int i = 0; i < storeLoopMax; i++) { if (currentItem->_itype != devilution::ItemType::None) { + if (checkRepairPrice) { + int v = 0; + int due = currentItem->_iMaxDur - currentItem->_iDurability; + if (currentItem->_iMagical != devilution::item_quality::ITEM_QUALITY_NORMAL && currentItem->_iIdentified) { + v = 30 * currentItem->_iIvalue * due / (currentItem->_iMaxDur * 100 * 2); + if (v == 0) + continue; + } + } + int itemID = static_cast(data->itemList.size()); + for (auto &item : data->itemList) { if (item.compare(*currentItem)) { itemID = item.ID; From e7dd6bbab5794293809b7994e54b5cd380d36be8 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Wed, 14 May 2025 13:03:41 -0400 Subject: [PATCH 19/32] Fix putCursorItem Need to explicitly check if HoldItem is empty in DevX --- Source/dapi/Server.cpp | 3 +++ 1 file changed, 3 insertions(+) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index ab904253e..57854a272 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -2187,6 +2187,9 @@ void Server::putInCursor(size_t itemID) void Server::putCursorItem(int location) { + if (devilution::MyPlayer->HoldItem.isEmpty()) + return; + EquipSlot equipLocation = static_cast(location); if (!data->invflag) From c3d6a459d2c18585ffd0aca0920f225443bb5367 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Wed, 14 May 2025 21:33:14 -0400 Subject: [PATCH 20/32] Fix Repairs and Identifying with Cain This actually fixes repairs (and selling), using CurrentItemIndex correctly and doesn't double dip into the players gold for repairs. Also fixes Cain identifies as before the store wasn't being re-ran after identifying an item. --- Source/dapi/Server.cpp | 21 ++++----------------- 1 file changed, 4 insertions(+), 17 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 57854a272..560f1524f 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1,6 +1,7 @@ #include #include "Server.h" +#include "qol\stash.h" @@ -995,21 +996,15 @@ void Server::updateGameData() devilution::Item *currentItem; bool useiValue = false; bool shiftValue = false; - bool checkRepairPrice = false; switch (devilution::ActiveStore) { case devilution::TalkID::StorytellerIdentify: case devilution::TalkID::WitchSell: case devilution::TalkID::WitchRecharge: case devilution::TalkID::SmithSell: - storeLoopMax = 48; - currentItem = &devilution::PlayerItems[0]; - useiValue = true; - break; case devilution::TalkID::SmithRepair: - storeLoopMax = 48; + storeLoopMax = devilution::CurrentItemIndex; currentItem = &devilution::PlayerItems[0]; useiValue = true; - checkRepairPrice = true; break; case devilution::TalkID::WitchBuy: storeLoopMax = devilution::NumWitchItemsHf; @@ -1039,16 +1034,6 @@ void Server::updateGameData() } for (int i = 0; i < storeLoopMax; i++) { if (currentItem->_itype != devilution::ItemType::None) { - if (checkRepairPrice) { - int v = 0; - int due = currentItem->_iMaxDur - currentItem->_iDurability; - if (currentItem->_iMagical != devilution::item_quality::ITEM_QUALITY_NORMAL && currentItem->_iIdentified) { - v = 30 * currentItem->_iIvalue * due / (currentItem->_iMaxDur * 100 * 2); - if (v == 0) - continue; - } - } - int itemID = static_cast(data->itemList.size()); @@ -1842,6 +1827,7 @@ void Server::repairItem(int itemID) myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._iDurability = myPlayer.InvBody[devilution::inv_body_loc::INVLOC_HAND_RIGHT]._iMaxDur; devilution::TakePlrsMoney(price); devilution::StartStore(devilution::OldActiveStore); + return; } myPlayer.InvList[i]._iDurability = myPlayer.InvList[i]._iMaxDur; @@ -2309,6 +2295,7 @@ void Server::identifyStoreItem(int itemID) devilution::PlayerItems[id]._iIdentified = true; devilution::TakePlrsMoney(devilution::PlayerItems[id]._iIvalue); devilution::CalcPlrInv(myPlayer, true); + devilution::StartStore(devilution::OldActiveStore); } } From 5e4afea8fcf8dc83dad0d0c0c57b7ba981435911 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Thu, 15 May 2025 08:33:48 -0400 Subject: [PATCH 21/32] Fix Player Information Fixes issue where player information was being given when players were not on the active floor. --- Source/dapi/Server.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 560f1524f..018ae9531 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -697,7 +697,7 @@ void Server::updateGameData() data->playerList[i]._pIBonusAC = devilution::Players[i]._pIBonusAC; data->playerList[i]._pIBonusDamMod = devilution::Players[i]._pIBonusDamMod; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; - } else if (devilution::Players.size() >= i + 1 && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { + } else if (devilution::Players.size() >= i + 1 && devilution::Players[i].isOnActiveLevel() && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); playerData->set__pname(data->playerList[i]._pName); From fbe37317b417207ad1fab6f8f8007192311e3935 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Thu, 22 May 2025 09:06:16 -0400 Subject: [PATCH 22/32] Fix Player Info Loop and Implement FPS Change --- Source/dapi/Server.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 018ae9531..0dac51512 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -554,7 +554,7 @@ void Server::updateGameData() data->groundItems.clear(); - for (size_t i = 0; i < devilution::gbActivePlayers; i++) { + for (size_t i = 0; i < (devilution::gbIsMultiplayer ? 4 : 1); /* devilution::gbActivePlayers;*/ i++) { auto playerData = update->add_playerdata(); data->playerList[i].InvBody.clear(); @@ -697,7 +697,7 @@ void Server::updateGameData() data->playerList[i]._pIBonusAC = devilution::Players[i]._pIBonusAC; data->playerList[i]._pIBonusDamMod = devilution::Players[i]._pIBonusDamMod; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; - } else if (devilution::Players.size() >= i + 1 && devilution::Players[i].isOnActiveLevel() && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { + } else if (devilution::Players.size() >= i + 1 && devilution::Players[i].plractive && devilution::Players[i].isOnActiveLevel() && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); playerData->set__pname(data->playerList[i]._pName); @@ -2327,6 +2327,8 @@ void Server::cancelQText() void Server::setFPS(int newFPS) { FPS = newFPS; + devilution::sgGameInitInfo.nTickRate = newFPS; + devilution::gnTickDelay = 1000 / devilution::sgGameInitInfo.nTickRate; } void Server::disarmTrap(int index) From e071612518b5568341dd06607917e1ec2627d95c Mon Sep 17 00:00:00 2001 From: staphen Date: Sun, 25 May 2025 00:13:55 -0400 Subject: [PATCH 23/32] Fix path separator in DAPI Server.cpp includes --- Source/dapi/Server.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 0dac51512..eba31d230 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -1,7 +1,7 @@ #include #include "Server.h" -#include "qol\stash.h" +#include "qol/stash.h" From 44cdd7a0272e622b8be7f4e4e14767e37e974ded Mon Sep 17 00:00:00 2001 From: staphen Date: Sun, 25 May 2025 00:15:53 -0400 Subject: [PATCH 24/32] Add CMake option to opt-in to DAPI --- CMake/Definitions.cmake | 1 + CMake/Dependencies.cmake | 8 ++-- CMake/VcPkgManifestFeatures.cmake | 3 ++ CMakeLists.txt | 2 + CMakeSettings.json | 24 +++++++++- Packaging/windows/CMakePresets.json | 4 ++ Source/CMakeLists.txt | 69 ++++++++++++++++------------- Source/diablo.cpp | 11 ++++- vcpkg.json | 8 ++-- 9 files changed, 91 insertions(+), 39 deletions(-) diff --git a/CMake/Definitions.cmake b/CMake/Definitions.cmake index ab85b1f8f..1db7245be 100644 --- a/CMake/Definitions.cmake +++ b/CMake/Definitions.cmake @@ -19,6 +19,7 @@ foreach( DEVILUTIONX_RESAMPLER_SDL DEVILUTIONX_PALETTE_TRANSPARENCY_BLACK_16_LUT SCREEN_READER_INTEGRATION + DAPI_SERVER UNPACKED_MPQS UNPACKED_SAVES DEVILUTIONX_WINDOWS_NO_WCHAR diff --git a/CMake/Dependencies.cmake b/CMake/Dependencies.cmake index 030781d8c..0968a42f2 100644 --- a/CMake/Dependencies.cmake +++ b/CMake/Dependencies.cmake @@ -276,7 +276,9 @@ if(GPERF) message("INFO: ${GPERFTOOLS_LIBRARIES}") endif() -find_package(SFML 3.0 COMPONENTS Network CONFIG QUIET) -if(NOT SFML_FOUND) - add_subdirectory(3rdParty/sfml) +if(DAPI_SERVER) + find_package(SFML 3.0 COMPONENTS Network CONFIG QUIET) + if(NOT SFML_FOUND) + add_subdirectory(3rdParty/sfml) + endif() endif() diff --git a/CMake/VcPkgManifestFeatures.cmake b/CMake/VcPkgManifestFeatures.cmake index de7359fa8..0ce00f29b 100644 --- a/CMake/VcPkgManifestFeatures.cmake +++ b/CMake/VcPkgManifestFeatures.cmake @@ -10,6 +10,9 @@ endif() if(USE_GETTEXT_FROM_VCPKG) list(APPEND VCPKG_MANIFEST_FEATURES "translations") endif() +if(DAPI_SERVER) + list(APPEND VCPKG_MANIFEST_FEATURES "dapi") +endif() if(BUILD_TESTING) list(APPEND VCPKG_MANIFEST_FEATURES "tests") endif() diff --git a/CMakeLists.txt b/CMakeLists.txt index d750b0a3e..d98f610cd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,6 +37,8 @@ cmake_dependent_option(PACKET_ENCRYPTION "Encrypt network packets" ON "NOT NONET if(CMAKE_TOOLCHAIN_FILE MATCHES "vcpkg.cmake$") option(USE_GETTEXT_FROM_VCPKG "Add vcpkg dependency for gettext[tools] for compiling translations" OFF) endif() +option(DAPI_SERVER "Build with DAPI server component for gameplay automation" OFF) +mark_as_advanced(DAPI_SERVER) option(BUILD_TESTING "Build tests." ON) # These must be included after the options above but before the `project` call. diff --git a/CMakeSettings.json b/CMakeSettings.json index 2041366d8..9a13ba0e0 100644 --- a/CMakeSettings.json +++ b/CMakeSettings.json @@ -12,7 +12,7 @@ "variables": [ { "name": "DISCORD_INTEGRATION", - "value": "False", + "value": "True", "type": "BOOL" } ] @@ -39,6 +39,28 @@ } ] }, + { + "name": "x64-Debug-DAPI", + "generator": "Ninja", + "configurationType": "Debug", + "buildRoot": "${workspaceRoot}\\build\\${name}", + "installRoot": "${env.USERPROFILE}\\CMakeBuilds\\${workspaceHash}\\install\\${name}", + "inheritEnvironments": [ "msvc_x64" ], + "intelliSenseMode": "windows-msvc-x64", + "enableClangTidyCodeAnalysis": true, + "variables": [ + { + "name": "DISCORD_INTEGRATION", + "value": "False", + "type": "BOOL" + }, + { + "name": "DAPI_SERVER", + "value": "True", + "type": "BOOL" + } + ] + }, { "name": "x64-Debug-SDL1", "generator": "Ninja", diff --git a/Packaging/windows/CMakePresets.json b/Packaging/windows/CMakePresets.json index c59a2c30c..55b092cfa 100644 --- a/Packaging/windows/CMakePresets.json +++ b/Packaging/windows/CMakePresets.json @@ -36,6 +36,10 @@ "DISABLE_LTO": { "type": "BOOL", "value": "ON" + }, + "DAPI_SERVER": { + "type": "BOOL", + "value": "ON" } } }, diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt index 09b565d48..83f4d2e67 100644 --- a/Source/CMakeLists.txt +++ b/Source/CMakeLists.txt @@ -649,14 +649,16 @@ if(DISCORD_INTEGRATION) ) endif() -list(APPEND libdevilutionx_SRCS - dapi/Server.cpp - dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp - dapi/Backend/Messages/command.proto - dapi/Backend/Messages/data.proto - dapi/Backend/Messages/game.proto - dapi/Backend/Messages/init.proto - dapi/Backend/Messages/message.proto) +if(DAPI_SERVER) + list(APPEND libdevilutionx_SRCS + dapi/Server.cpp + dapi/Backend/DAPIBackendCore/DAPIProtoClient.cpp + dapi/Backend/Messages/command.proto + dapi/Backend/Messages/data.proto + dapi/Backend/Messages/game.proto + dapi/Backend/Messages/init.proto + dapi/Backend/Messages/message.proto) +endif() if(SCREEN_READER_INTEGRATION) list(APPEND libdevilutionx_SRCS @@ -684,7 +686,6 @@ target_link_dependencies(libdevilutionx PUBLIC libsmackerdec ${LUA_LIBRARIES} sol2::sol2 - SFML::Network tl unordered_dense::unordered_dense libdevilutionx_assets @@ -752,6 +753,10 @@ if(DISCORD_INTEGRATION) target_link_libraries(libdevilutionx PRIVATE discord discord_game_sdk) endif() +if(DAPI_SERVER) + target_link_libraries(libdevilutionx PRIVATE SFML::Network) +endif() + if(SCREEN_READER_INTEGRATION) if(WIN32) target_compile_definitions(libdevilutionx PRIVATE Tolk) @@ -807,25 +812,27 @@ elseif(CMAKE_CXX_COMPILER_ID MATCHES "Clang") endif() endif() -find_package(Protobuf REQUIRED) - -target_link_libraries(libdevilutionx PUBLIC protobuf::libprotobuf-lite) -find_package(absl REQUIRED) -set(PROTO_BINARY_DIR "${CMAKE_BINARY_DIR}/generated") - -file(MAKE_DIRECTORY ${PROTO_BINARY_DIR}) - -target_include_directories(libdevilutionx PRIVATE ${Protobuf_INCLUDE_DIRS}) - -# Generate the protobuf files into the 'generated' directory within the build tree -protobuf_generate( - TARGET libdevilutionx - IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/Messages" - PROTOC_OUT_DIR "${PROTO_BINARY_DIR}" -) - -# Make sure the generated protobuf files are correctly included in the build -target_include_directories(libdevilutionx PUBLIC "$") -include_directories("${PROTO_BINARY_DIR}/dapi/Backend/Messages") - -target_include_directories(libdevilutionx PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/DAPIBackendCore") +if(DAPI_SERVER) + find_package(Protobuf REQUIRED) + + target_link_libraries(libdevilutionx PUBLIC protobuf::libprotobuf-lite) + find_package(absl REQUIRED) + set(PROTO_BINARY_DIR "${CMAKE_BINARY_DIR}/generated") + + file(MAKE_DIRECTORY ${PROTO_BINARY_DIR}) + + target_include_directories(libdevilutionx PRIVATE ${Protobuf_INCLUDE_DIRS}) + + # Generate the protobuf files into the 'generated' directory within the build tree + protobuf_generate( + TARGET libdevilutionx + IMPORT_DIRS "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/Messages" + PROTOC_OUT_DIR "${PROTO_BINARY_DIR}" + ) + + # Make sure the generated protobuf files are correctly included in the build + target_include_directories(libdevilutionx PUBLIC "$") + include_directories("${PROTO_BINARY_DIR}/dapi/Backend/Messages") + + target_include_directories(libdevilutionx PUBLIC "${CMAKE_CURRENT_SOURCE_DIR}/dapi/Backend/DAPIBackendCore") +endif() diff --git a/Source/diablo.cpp b/Source/diablo.cpp index 1aea08810..3cbb64f89 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -26,7 +26,6 @@ #include "controls/keymapper.hpp" #include "controls/plrctrls.h" #include "controls/remap_keyboard.h" -#include "dapi/Server.h" #include "diablo.h" #include "diablo_msg.hpp" #include "discord/discord.h" @@ -108,6 +107,10 @@ #include "controls/touch/renderers.h" #endif +#ifdef DAPI_SERVER +#include "dapi/Server.h" +#endif + #ifdef __vita__ #include "platform/vita/touch.h" #endif @@ -133,7 +136,9 @@ clicktype sgbMouseDown; uint16_t gnTickDelay = 50; char gszProductName[64] = "DevilutionX vUnknown"; +#ifdef DAPI_SERVER DAPI::Server dapiServer; +#endif #ifdef _DEBUG bool DebugDisableNetworkTimeout = false; @@ -1459,11 +1464,15 @@ void UpdateMonsterLights() void GameLogic() { if (!ProcessInput()) { +#ifdef DAPI_SERVER if (gmenu_is_active()) dapiServer.update(); // For game menu commands +#endif return; } +#ifdef DAPI_SERVER dapiServer.update(); +#endif if (gbProcessPlayers) { gGameLogicStep = GameLogicStep::ProcessPlayers; ProcessPlayers(); diff --git a/vcpkg.json b/vcpkg.json index 759e23cce..5136ac7a7 100644 --- a/vcpkg.json +++ b/vcpkg.json @@ -4,9 +4,7 @@ "dependencies": [ "fmt", "bzip2", - "lua", - "protobuf", - "sfml" + "lua" ], "builtin-baseline": "533a5fda5c0646d1771345fb572e759283444d5f", "features": { @@ -31,6 +29,10 @@ } ] }, + "dapi": { + "description": "Build DAPI server for gameplay automation", + "dependencies": [ "protobuf", "sfml" ] + }, "tests": { "description": "Build tests", "dependencies": [ "gtest", "benchmark" ] From 62c1a077fcb77dd04deed2f442563c94254e8026 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sun, 25 May 2025 10:15:18 -0400 Subject: [PATCH 25/32] Add Initial Chat Functionality Moves three chat log items to devilution namespace and adds commands for reading from and writing to chat. --- Source/dapi/Backend/Messages/command.proto | 5 ++++ Source/dapi/Backend/Messages/game.proto | 1 + Source/dapi/GameData.h | 1 + Source/dapi/Server.cpp | 34 ++++++++++++++++++++++ Source/dapi/Server.h | 2 ++ Source/qol/chatlog.cpp | 14 ++------- Source/qol/chatlog.h | 11 +++++++ 7 files changed, 56 insertions(+), 12 deletions(-) diff --git a/Source/dapi/Backend/Messages/command.proto b/Source/dapi/Backend/Messages/command.proto index ced3e1f05..c9c365624 100644 --- a/Source/dapi/Backend/Messages/command.proto +++ b/Source/dapi/Backend/Messages/command.proto @@ -141,6 +141,10 @@ message IdentifyItem { uint32 ID = 1; } +message SendChat { + string message = 1; +} + message Command { oneof command { Move move = 1; @@ -176,5 +180,6 @@ message Command { Quit quit = 31; ClearCursor clearCursor = 32; IdentifyItem identifyItem = 33; + SendChat sendChat = 34; } } diff --git a/Source/dapi/Backend/Messages/game.proto b/Source/dapi/Backend/Messages/game.proto index df7e58a26..a5d28451e 100644 --- a/Source/dapi/Backend/Messages/game.proto +++ b/Source/dapi/Backend/Messages/game.proto @@ -34,4 +34,5 @@ message FrameUpdate { repeated dapi.data.MissileData missileData = 26; repeated dapi.data.PortalData portalData = 27; repeated dapi.data.QuestData questData = 28; + repeated string chatMessages = 29; } diff --git a/Source/dapi/GameData.h b/Source/dapi/GameData.h index 0edd16505..0a245483e 100644 --- a/Source/dapi/GameData.h +++ b/Source/dapi/GameData.h @@ -31,6 +31,7 @@ struct GameData { bool invflag; bool qtextflag; int currlevel; + size_t lastLogSize; std::map playerList; std::vector itemList; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index eba31d230..bb90a8f9f 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -201,6 +201,9 @@ void Server::processMessages() } else if (command.has_identifyitem()) { auto identifyItem = command.identifyitem(); this->identifyItem(identifyItem.id()); + } else if (command.has_sendchat()) { + auto sendChat = command.sendchat(); + this->sendChat(sendChat.message()); } issuedCommand = true; if (command.has_setfps()) { @@ -414,6 +417,24 @@ void Server::updateGameData() update->set_connectedto(1); + for (auto chatLogLine = data->lastLogSize; chatLogLine < devilution::ChatLogLines.size(); chatLogLine++) + { + std::stringstream message; + for (auto &textLine : devilution::ChatLogLines[chatLogLine].colors) + { + if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhitegold & devilution::UiFlags::ColorBlue)) + message << textLine.text << ": "; + if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhite)) + message << textLine.text; + } + if (message.str().size()) + { + auto chatMessage = update->add_chatmessages(); + *chatMessage = message.str(); + } + } + data->lastLogSize = devilution::ChatLogLines.size(); + update->set_player(devilution::MyPlayerId); update->set_stextflag(static_cast(devilution::ActiveStore)); @@ -2448,4 +2469,17 @@ void Server::identifyItem(int itemID) } } } + +void Server::sendChat(std::string message) +{ + if (!devilution::gbIsMultiplayer) + return; + + if (79 < message.length()) + message = message.substr(0, 79); + + char charMsg[MAX_SEND_STR_LEN]; + devilution::CopyUtf8(charMsg, message, sizeof(charMsg)); + devilution::NetSendCmdString(0xFFFFFF, charMsg); +} } // namespace DAPI diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h index 69f69052f..af1247b8d 100644 --- a/Source/dapi/Server.h +++ b/Source/dapi/Server.h @@ -25,6 +25,7 @@ #include "msg.h" #include "engine/random.hpp" #include "gamemenu.h" +#include "qol/chatlog.h" namespace DAPI { enum struct CommandType { @@ -247,6 +248,7 @@ private: void quit(); void clearCursor(); void identifyItem(int itemID); + void sendChat(std::string message); bool listening = false; diff --git a/Source/qol/chatlog.cpp b/Source/qol/chatlog.cpp index 5704cdd5d..fc1065623 100644 --- a/Source/qol/chatlog.cpp +++ b/Source/qol/chatlog.cpp @@ -27,24 +27,14 @@ namespace devilution { -namespace { - -struct ColoredText { - std::string text; - UiFlags color; -}; +std::vector ChatLogLines; -struct MultiColoredText { - std::string text; - std::vector colors; -}; +namespace { bool UnreadFlag = false; size_t SkipLines; unsigned int MessageCounter = 0; -std::vector ChatLogLines; - constexpr int PaddingTop = 32; constexpr int PaddingLeft = 32; diff --git a/Source/qol/chatlog.h b/Source/qol/chatlog.h index 5291684f5..c13b1cde2 100644 --- a/Source/qol/chatlog.h +++ b/Source/qol/chatlog.h @@ -11,7 +11,18 @@ namespace devilution { +struct ColoredText { + std::string text; + UiFlags color; +}; + +struct MultiColoredText { + std::string text; + std::vector colors; +}; + extern bool ChatLogFlag; +extern std::vector ChatLogLines; void ToggleChatLog(); void AddMessageToChatLog(std::string_view message, Player *player = nullptr, UiFlags flags = UiFlags::ColorWhite); From 8b2a26c84a37317918ee96a91f282201e338cfda Mon Sep 17 00:00:00 2001 From: staphen Date: Sun, 25 May 2025 10:39:25 -0400 Subject: [PATCH 26/32] Apply clang-format --- Source/dapi/Player.h | 1 - Source/dapi/Server.cpp | 41 ++++++++++++++++------------------------- Source/dapi/Server.h | 22 +++++++++++----------- Source/diablo.h | 1 - Source/stores.cpp | 2 -- Source/stores.h | 2 +- 6 files changed, 28 insertions(+), 41 deletions(-) diff --git a/Source/dapi/Player.h b/Source/dapi/Player.h index bbb07286a..0ec03fa7e 100644 --- a/Source/dapi/Player.h +++ b/Source/dapi/Player.h @@ -1,7 +1,6 @@ #pragma once #include "Item.h" - namespace DAPI { const int NUM_INVLOC = 7; const int MAXINV = 40; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index bb90a8f9f..45855c886 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -3,8 +3,6 @@ #include "Server.h" #include "qol/stash.h" - - namespace DAPI { Server::Server() : FPS(20) @@ -417,18 +415,15 @@ void Server::updateGameData() update->set_connectedto(1); - for (auto chatLogLine = data->lastLogSize; chatLogLine < devilution::ChatLogLines.size(); chatLogLine++) - { + for (auto chatLogLine = data->lastLogSize; chatLogLine < devilution::ChatLogLines.size(); chatLogLine++) { std::stringstream message; - for (auto &textLine : devilution::ChatLogLines[chatLogLine].colors) - { + for (auto &textLine : devilution::ChatLogLines[chatLogLine].colors) { if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhitegold & devilution::UiFlags::ColorBlue)) message << textLine.text << ": "; if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhite)) message << textLine.text; } - if (message.str().size()) - { + if (message.str().size()) { auto chatMessage = update->add_chatmessages(); *chatMessage = message.str(); } @@ -465,8 +460,7 @@ void Server::updateGameData() qtextss << line; } update->set_qtext(qtextss.str().c_str()); - } - else + } else update->set_qtext(""); update->set_fps(FPS); if (!devilution::gbIsMultiplayer) @@ -1057,7 +1051,6 @@ void Server::updateGameData() if (currentItem->_itype != devilution::ItemType::None) { int itemID = static_cast(data->itemList.size()); - for (auto &item : data->itemList) { if (item.compare(*currentItem)) { itemID = item.ID; @@ -1272,7 +1265,7 @@ void Server::updateGameData() } } - for (auto& missile : devilution::Missiles) { + for (auto &missile : devilution::Missiles) { if (isOnScreen(missile.position.tile.x, missile.position.tile.y)) fillMissile(missile); } @@ -1495,13 +1488,12 @@ void Server::buyItem(int itemID) if (idx == -1) return; - devilution::PlaySFX(devilution::SfxID::MenuSelect); + devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::OldTextLine = devilution::CurrentTextLine; devilution::OldScrollPos = devilution::ScrollPos; devilution::OldActiveStore = devilution::ActiveStore; - if (!devilution::PlayerCanAfford(devilution::WitchItems[idx]._iIvalue)) { devilution::StartStore(devilution::TalkID::NoMoney); return; @@ -1511,14 +1503,13 @@ void Server::buyItem(int itemID) devilution::TakePlrsMoney(devilution::WitchItems[idx]._iIvalue); - if (idx >= 3) { if (idx == devilution::NumWitchItemsHf - 1) devilution::WitchItems[devilution::NumWitchItemsHf - 1].clear(); else { - for (; !devilution::WitchItems[idx + 1].isEmpty(); idx++) { - devilution::WitchItems[idx] = std::move(devilution::WitchItems[idx + 1]); - } + for (; !devilution::WitchItems[idx + 1].isEmpty(); idx++) { + devilution::WitchItems[idx] = std::move(devilution::WitchItems[idx + 1]); + } devilution::WitchItems[idx].clear(); } } @@ -1700,7 +1691,7 @@ void Server::sellItem(int itemID) { int idx; - if (devilution::ActiveStore != devilution::TalkID::WitchSell &&devilution::ActiveStore != devilution::TalkID::SmithSell) + if (devilution::ActiveStore != devilution::TalkID::WitchSell && devilution::ActiveStore != devilution::TalkID::SmithSell) return; idx = -1; @@ -2208,7 +2199,7 @@ void Server::putCursorItem(int location) devilution::Displacement hotPixelCellOffset; if (equipLocation == EquipSlot::LEFTRING) { invRectIndex = 1; - } else if (equipLocation == EquipSlot::RIGHTRING) { + } else if (equipLocation == EquipSlot::RIGHTRING) { invRectIndex = 2; } if (equipLocation < EquipSlot::BELT1) { @@ -2217,11 +2208,11 @@ void Server::putCursorItem(int location) panelOffset = devilution::GetMainPanel().position - devilution::Point { 0, 0 }; } if (EquipSlot::INV1 <= equipLocation && equipLocation <= EquipSlot::INV40) { - const devilution::Size itemSize = devilution::GetInventorySize(devilution::MyPlayer->HoldItem); - if (itemSize.height <= 1 && itemSize.width <= 1) { - hotPixelCellOffset = devilution::Displacement { 1, 1 }; - } - hotPixelCellOffset = { (itemSize.width - 1) / 2 + 19, (itemSize.height - 1) / 2 + 19}; + const devilution::Size itemSize = devilution::GetInventorySize(devilution::MyPlayer->HoldItem); + if (itemSize.height <= 1 && itemSize.width <= 1) { + hotPixelCellOffset = devilution::Displacement { 1, 1 }; + } + hotPixelCellOffset = { (itemSize.width - 1) / 2 + 19, (itemSize.height - 1) / 2 + 19 }; } else { hotPixelCellOffset = devilution::Displacement { 1, 1 }; } diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h index af1247b8d..31d95c51e 100644 --- a/Source/dapi/Server.h +++ b/Source/dapi/Server.h @@ -7,25 +7,25 @@ #include "Backend/DAPIBackendCore/DAPIProtoClient.h" #include "GameData.h" -#include "spelldat.h" -#include "player.h" #include "control.h" -#include "inv.h" -#include "towners.h" -#include "stores.h" +#include "cursor.h" #include "diablo.h" +#include "engine/random.hpp" +#include "gamemenu.h" #include "gmenu.h" -#include "cursor.h" -#include "minitext.h" +#include "inv.h" #include "levels/gendung.h" +#include "minitext.h" +#include "missiles.h" +#include "msg.h" #include "multi.h" #include "objects.h" -#include "missiles.h" +#include "player.h" #include "portal.h" -#include "msg.h" -#include "engine/random.hpp" -#include "gamemenu.h" #include "qol/chatlog.h" +#include "spelldat.h" +#include "stores.h" +#include "towners.h" namespace DAPI { enum struct CommandType { diff --git a/Source/diablo.h b/Source/diablo.h index 8be060669..de321dccb 100644 --- a/Source/diablo.h +++ b/Source/diablo.h @@ -79,7 +79,6 @@ extern clicktype sgbMouseDown; extern uint16_t gnTickDelay; extern char gszProductName[64]; - extern MouseActionType LastMouseButtonAction; void InitKeymapActions(); diff --git a/Source/stores.cpp b/Source/stores.cpp index c2ac52b49..119a610f9 100644 --- a/Source/stores.cpp +++ b/Source/stores.cpp @@ -74,8 +74,6 @@ int CurrentTextLine; namespace { - - /** Is the current dialog full size */ bool IsTextFullSize; diff --git a/Source/stores.h b/Source/stores.h index fc30c26eb..5c2449ec3 100644 --- a/Source/stores.h +++ b/Source/stores.h @@ -13,8 +13,8 @@ #include "engine/clx_sprite.hpp" #include "engine/surface.hpp" #include "game_mode.hpp" -#include "utils/attributes.h" #include "towners.h" +#include "utils/attributes.h" namespace devilution { From f384704c3feaa1230ae903847ed293fe96153086 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sat, 31 May 2025 09:42:03 -0400 Subject: [PATCH 27/32] Chat Message Changes This will need to be changed again to fix longer chat messages, but as long as a message doesn't trigger wordwrap in the message log this works. --- Source/dapi/Server.cpp | 6 +++--- Source/qol/chatlog.cpp | 2 +- Source/qol/chatlog.h | 1 + 3 files changed, 5 insertions(+), 4 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 45855c886..32acc8df8 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -415,10 +415,10 @@ void Server::updateGameData() update->set_connectedto(1); - for (auto chatLogLine = data->lastLogSize; chatLogLine < devilution::ChatLogLines.size(); chatLogLine++) { + for (auto chatLogLine = devilution::ChatLogLines.size() - (devilution::MessageCounter - data->lastLogSize); chatLogLine < devilution::ChatLogLines.size(); chatLogLine++) { std::stringstream message; for (auto &textLine : devilution::ChatLogLines[chatLogLine].colors) { - if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhitegold & devilution::UiFlags::ColorBlue)) + if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhitegold) || devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorBlue)) message << textLine.text << ": "; if (devilution::HasAnyOf(textLine.color, devilution::UiFlags::ColorWhite)) message << textLine.text; @@ -428,7 +428,7 @@ void Server::updateGameData() *chatMessage = message.str(); } } - data->lastLogSize = devilution::ChatLogLines.size(); + data->lastLogSize = devilution::MessageCounter; update->set_player(devilution::MyPlayerId); diff --git a/Source/qol/chatlog.cpp b/Source/qol/chatlog.cpp index fc1065623..999f8ac16 100644 --- a/Source/qol/chatlog.cpp +++ b/Source/qol/chatlog.cpp @@ -28,12 +28,12 @@ namespace devilution { std::vector ChatLogLines; +unsigned int MessageCounter = 0; namespace { bool UnreadFlag = false; size_t SkipLines; -unsigned int MessageCounter = 0; constexpr int PaddingTop = 32; constexpr int PaddingLeft = 32; diff --git a/Source/qol/chatlog.h b/Source/qol/chatlog.h index c13b1cde2..e73990024 100644 --- a/Source/qol/chatlog.h +++ b/Source/qol/chatlog.h @@ -23,6 +23,7 @@ struct MultiColoredText { extern bool ChatLogFlag; extern std::vector ChatLogLines; +extern unsigned int MessageCounter; void ToggleChatLog(); void AddMessageToChatLog(std::string_view message, Player *player = nullptr, UiFlags flags = UiFlags::ColorWhite); From b48635623f9fc5f836158d08d3c88b4516373835 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Sat, 31 May 2025 09:45:26 -0400 Subject: [PATCH 28/32] Add Map Include to Player.h Adds Map Include to Player.h to remove clang-tidy warnings --- Source/dapi/Player.h | 1 + 1 file changed, 1 insertion(+) diff --git a/Source/dapi/Player.h b/Source/dapi/Player.h index 0ec03fa7e..e05103b40 100644 --- a/Source/dapi/Player.h +++ b/Source/dapi/Player.h @@ -1,5 +1,6 @@ #pragma once #include "Item.h" +#include namespace DAPI { const int NUM_INVLOC = 7; From 09141118dea2ffb7f11d4a0f02d8731afd0ee5b9 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Mon, 8 Dec 2025 23:27:26 -0500 Subject: [PATCH 29/32] Fix Handling Item Purchases Fixes handling of item purchases to work with the new StaticVector class and corrects a DevilutionX function definition that for some reason didn't update when I merged master. --- Source/dapi/Server.cpp | 79 +++++++++++++++--------------------------- Source/stores.cpp | 2 +- 2 files changed, 29 insertions(+), 52 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 32acc8df8..5d9229b80 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -102,6 +102,8 @@ void Server::processMessages() { bool issuedCommand = false; while (protoClient.messageQueueSize()) { + if (devilution::MonstersData.size() != 138) + issuedCommand = false; auto message = protoClient.getNextMessage(); if (message.get() == nullptr) return; @@ -1022,21 +1024,21 @@ void Server::updateGameData() useiValue = true; break; case devilution::TalkID::WitchBuy: - storeLoopMax = devilution::NumWitchItemsHf; + storeLoopMax = devilution::WitchItems.size(); currentItem = &devilution::WitchItems[0]; break; case devilution::TalkID::SmithBuy: - storeLoopMax = devilution::NumSmithBasicItemsHf; + storeLoopMax = devilution::SmithItems.size(); currentItem = &devilution::SmithItems[0]; useiValue = true; break; case devilution::TalkID::HealerBuy: - storeLoopMax = devilution::NumHealerItemsHf; + storeLoopMax = devilution::HealerItems.size(); currentItem = &devilution::HealerItems[0]; useiValue = true; break; case devilution::TalkID::SmithPremiumBuy: - storeLoopMax = devilution::NumSmithItemsHf; + storeLoopMax = devilution::PremiumItems.size(); currentItem = &devilution::PremiumItems[0]; break; case devilution::TalkID::BoyBuy: @@ -1082,7 +1084,8 @@ void Server::updateGameData() townerData._ty = -1; } } else { - for (auto i = 0; devilution::gbIsHellfire ? i < NUM_TOWNERS : i < 12; i++) { + for (auto &towner : devilution::Towners) + for (auto i = 0; i < devilution::Towners.size(); i++) { auto townerID = i; auto &towner = data->townerList[townerID]; towner.ID = static_cast(townerID); @@ -1324,11 +1327,11 @@ void Server::move(int x, int y) void Server::talk(int x, int y) { int index; - for (index = 0; index < NUM_TOWNERS; index++) { + for (index = 0; index < devilution::Towners.size(); index++) { if (devilution::Towners[index].position.x == x && devilution::Towners[index].position.y == y) break; } - if (index != NUM_TOWNERS) + if (index != devilution::Towners.size()) devilution::NetSendCmdLocParam1(true, devilution::_cmd_id::CMD_TALKXY, devilution::Point { x, y }, index); } @@ -1478,7 +1481,7 @@ void Server::buyItem(int itemID) idx = -1; - for (int i = 0; i < 20; i++) { + for (int i = 0; i < devilution::WitchItems.size(); i++) { if (data->itemList[itemID].compare(devilution::WitchItems[i])) { idx = i; break; @@ -1497,33 +1500,27 @@ void Server::buyItem(int itemID) if (!devilution::PlayerCanAfford(devilution::WitchItems[idx]._iIvalue)) { devilution::StartStore(devilution::TalkID::NoMoney); return; - } else if (devilution::StoreAutoPlace(devilution::WitchItems[idx], true)) { + } else if (!devilution::StoreAutoPlace(devilution::WitchItems[idx], false)) { + devilution::StartStore(devilution::TalkID::NoRoom); + return; + } else { if (idx < 3) devilution::WitchItems[idx]._iSeed = devilution::AdvanceRndSeed(); devilution::TakePlrsMoney(devilution::WitchItems[idx]._iIvalue); + devilution::StoreAutoPlace(devilution::WitchItems[idx], true); if (idx >= 3) { - if (idx == devilution::NumWitchItemsHf - 1) - devilution::WitchItems[devilution::NumWitchItemsHf - 1].clear(); - else { - for (; !devilution::WitchItems[idx + 1].isEmpty(); idx++) { - devilution::WitchItems[idx] = std::move(devilution::WitchItems[idx + 1]); - } - devilution::WitchItems[idx].clear(); - } + devilution::WitchItems.erase(devilution::WitchItems.begin() + idx); } devilution::CalcPlrInv(*devilution::MyPlayer, true); - } else { - devilution::StartStore(devilution::TalkID::NoRoom); - return; } devilution::StartStore(devilution::OldActiveStore); } else if (devilution::ActiveStore == devilution::TalkID::SmithBuy) { idx = -1; - for (int i = 0; i < 20; i++) { + for (int i = 0; i < devilution::SmithItems.size(); i++) { if (data->itemList[itemID].compare(devilution::SmithItems[i])) { idx = i; break; @@ -1549,20 +1546,13 @@ void Server::buyItem(int itemID) if (devilution::SmithItems[idx]._iMagical == devilution::item_quality::ITEM_QUALITY_NORMAL) devilution::SmithItems[idx]._iIdentified = false; devilution::StoreAutoPlace(devilution::SmithItems[idx], true); - if (idx == devilution::NumSmithBasicItemsHf - 1) { - devilution::SmithItems[devilution::NumSmithBasicItemsHf - 1].clear(); - } else { - for (; !devilution::SmithItems[idx + 1].isEmpty(); idx++) { - devilution::SmithItems[idx] = std::move(devilution::SmithItems[idx + 1]); - } - devilution::SmithItems[idx].clear(); - } + devilution::SmithItems.erase(devilution::SmithItems.begin() + idx); devilution::CalcPlrInv(*devilution::MyPlayer, true); devilution::StartStore(devilution::OldActiveStore); } } else if (devilution::ActiveStore == devilution::TalkID::SmithPremiumBuy) { int idx = -1; - for (int i = 0; i < 20; i++) { + for (int i = 0; i < devilution::PremiumItems.size(); i++) { if (data->itemList[itemID].compare(devilution::PremiumItems[i])) { idx = i; break; @@ -1589,21 +1579,14 @@ void Server::buyItem(int itemID) if (devilution::PremiumItems[idx]._iMagical == devilution::item_quality::ITEM_QUALITY_NORMAL) devilution::PremiumItems[idx]._iIdentified = false; devilution::StoreAutoPlace(devilution::PremiumItems[idx], true); - if (idx == devilution::NumSmithBasicItemsHf - 1) { - devilution::PremiumItems[devilution::NumSmithBasicItemsHf - 1].clear(); - } else { - for (; !devilution::PremiumItems[idx + 1].isEmpty(); idx++) { - devilution::PremiumItems[idx] = std::move(devilution::PremiumItems[idx + 1]); - } - devilution::PremiumItems[idx].clear(); - } + devilution::ReplacePremium(*devilution::MyPlayer, idx); devilution::CalcPlrInv(*devilution::MyPlayer, true); devilution::StartStore(devilution::OldActiveStore); } } else if (devilution::ActiveStore == devilution::TalkID::HealerBuy) { idx = -1; - for (int i = 0; i < 20; i++) { + for (int i = 0; i < devilution::HealerItems.size(); i++) { if (data->itemList[itemID].compare(devilution::HealerItems[i])) { idx = i; break; @@ -1646,17 +1629,10 @@ void Server::buyItem(int itemID) if (idx < 3) return; } + devilution::HealerItems.erase(devilution::HealerItems.begin() + idx); + CalcPlrInv(*devilution::MyPlayer, true); + devilution::StartStore(devilution::OldActiveStore); } - if (idx == 19) { - devilution::HealerItems[19].clear(); - } else { - for (; !devilution::HealerItems[idx + 1].isEmpty(); idx++) { - devilution::HealerItems[idx] = std::move(devilution::HealerItems[idx + 1]); - } - devilution::HealerItems[idx].clear(); - } - CalcPlrInv(*devilution::MyPlayer, true); - devilution::StartStore(devilution::OldActiveStore); } else if (devilution::ActiveStore == devilution::TalkID::BoyBuy) { devilution::PlaySFX(devilution::SfxID::MenuSelect); @@ -1681,9 +1657,10 @@ void Server::buyItem(int itemID) devilution::StoreAutoPlace(devilution::BoyItem, true); devilution::BoyItem.clear(); devilution::OldActiveStore = devilution::TalkID::Boy; + devilution::CalcPlrInv(*devilution::MyPlayer, true); devilution::OldTextLine = 12; + devilution::StartStore(devilution::OldActiveStore); } - devilution::StartStore(devilution::OldActiveStore); } } @@ -1724,7 +1701,7 @@ void Server::sellItem(int itemID) else myPlayer.RemoveSpdBarItem(-(devilution::PlayerItemIndexes[idx] + 1)); - int cost = devilution::PlayerItems[idx]._iIvalue; + const int cost = devilution::PlayerItems[idx]._iIvalue; devilution::CurrentItemIndex--; if (idx != devilution::CurrentItemIndex) { while (idx < devilution::CurrentItemIndex) { diff --git a/Source/stores.cpp b/Source/stores.cpp index 34d97817a..e03971f4c 100644 --- a/Source/stores.cpp +++ b/Source/stores.cpp @@ -307,7 +307,7 @@ void PrintStoreItem(const Item &item, int l, UiFlags flags, bool cursIndent = fa AddSText(40, l++, productLine, flags, false, -1, cursIndent); } -void ScrollVendorStore(Item *itemData, int storeLimit, int idx, int selling = true) +void ScrollVendorStore(std::span itemData, int storeLimit, int idx, int selling = true) { ClearSText(5, 21); PreviousScrollPos = 5; From 15c38b4792d238572f2a516b36fa82a46f736e56 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Fri, 19 Dec 2025 21:13:25 -0500 Subject: [PATCH 30/32] Add _pISplLvlAdd to PlayerData Adds collecting _pISplLvlAdd to PlayerData server side and sending it client side. --- Source/dapi/Backend/Messages/data.proto | 3 ++- Source/dapi/Player.h | 1 + Source/dapi/Server.cpp | 4 ++++ 3 files changed, 7 insertions(+), 1 deletion(-) diff --git a/Source/dapi/Backend/Messages/data.proto b/Source/dapi/Backend/Messages/data.proto index ed8876a3e..08965ba1c 100644 --- a/Source/dapi/Backend/Messages/data.proto +++ b/Source/dapi/Backend/Messages/data.proto @@ -174,5 +174,6 @@ message PlayerData { uint32 _pIBonusToHit = 47; uint32 _pIBonusAC = 48; uint32 _pIBonusDamMod = 49; - bool pManaShield = 50; + int32 _pISplLvlAdd = 50; + bool pManaShield = 51; } diff --git a/Source/dapi/Player.h b/Source/dapi/Player.h index e05103b40..8fb946227 100644 --- a/Source/dapi/Player.h +++ b/Source/dapi/Player.h @@ -69,6 +69,7 @@ struct PlayerData { int _pIBonusToHit; int _pIBonusAC; int _pIBonusDamMod; + char _pISplLvlAdd; bool pManaShield; }; } // namespace DAPI diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 5d9229b80..baaf8c55d 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -713,6 +713,7 @@ void Server::updateGameData() data->playerList[i]._pIBonusToHit = devilution::Players[i]._pIBonusToHit; data->playerList[i]._pIBonusAC = devilution::Players[i]._pIBonusAC; data->playerList[i]._pIBonusDamMod = devilution::Players[i]._pIBonusDamMod; + data->playerList[i]._pISplLvlAdd = devilution::Players[i]._pISplLvlAdd; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; } else if (devilution::Players.size() >= i + 1 && devilution::Players[i].plractive && devilution::Players[i].isOnActiveLevel() && devilution::IsTileLit(devilution::Point { devilution::Players[i].position.tile.x, devilution::Players[i].position.tile.y })) { memcpy(data->playerList[i]._pName, devilution::Players[i]._pName, 32); @@ -779,6 +780,7 @@ void Server::updateGameData() data->playerList[i]._pIBonusToHit = -1; data->playerList[i]._pIBonusAC = -1; data->playerList[i]._pIBonusDamMod = -1; + data->playerList[i]._pISplLvlAdd = -1; data->playerList[i].pManaShield = devilution::Players[i].pManaShield; } else { memset(data->playerList[i]._pName, 0, 32); @@ -845,6 +847,7 @@ void Server::updateGameData() data->playerList[i]._pIBonusToHit = -1; data->playerList[i]._pIBonusAC = -1; data->playerList[i]._pIBonusDamMod = -1; + data->playerList[i]._pISplLvlAdd = -1; data->playerList[i].pManaShield = false; } @@ -911,6 +914,7 @@ void Server::updateGameData() playerData->set__pibonustohit(data->playerList[i]._pIBonusToHit); playerData->set__pibonusac(data->playerList[i]._pIBonusAC); playerData->set__pibonusdammod(data->playerList[i]._pIBonusDamMod); + playerData->set__pispllvladd(data->playerList[i]._pISplLvlAdd); playerData->set_pmanashield(data->playerList[i].pManaShield); } From de76ec1d85bc5ff9655110dcdafcfffad85cef19 Mon Sep 17 00:00:00 2001 From: NiteKat Date: Mon, 22 Dec 2025 20:00:21 -0500 Subject: [PATCH 31/32] Fix API Item Dropping Fixes an issue that started after updating to newer commit. Moves TryOpenDungeonWithMouse() to devilution namespace for access in the API and copies part of the left click code with slight modification to handle dropping items, and sets me up for implementing API opening hellfire areas. --- Source/dapi/Server.cpp | 13 +++++++++---- Source/diablo.cpp | 34 +++++++++++++++++----------------- Source/diablo.h | 1 + 3 files changed, 27 insertions(+), 21 deletions(-) diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index baaf8c55d..6edc078aa 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -2206,10 +2206,15 @@ void Server::dropCursorItem() { if (!isOnScreen(devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y)) return; - - if (12 <= devilution::pcurs) { - devilution::NetSendCmdPItem(true, devilution::_cmd_id::CMD_PUTITEM, devilution::Point { devilution::Players[devilution::MyPlayerId].position.tile.x, devilution::Players[devilution::MyPlayerId].position.tile.y }, devilution::MyPlayer->HoldItem); - devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); + else if (!devilution::MyPlayer->HoldItem.isEmpty()) { + if (!devilution::TryOpenDungeonWithMouse()) { + const devilution::Point currentPosition = devilution::MyPlayer->position.tile; + std::optional itemTile = FindAdjacentPositionForItem(currentPosition, GetDirection(currentPosition, devilution::MyPlayer->position.tile)); + if (itemTile) { + NetSendCmdPItem(true, devilution::_cmd_id::CMD_PUTITEM, *itemTile, devilution::MyPlayer->HoldItem); + devilution::NewCursor(devilution::cursor_id::CURSOR_HAND); + } + } } } diff --git a/Source/diablo.cpp b/Source/diablo.cpp index 122fab27e..a707b2480 100644 --- a/Source/diablo.cpp +++ b/Source/diablo.cpp @@ -320,23 +320,6 @@ void LeftMouseCmd(bool bShift) } } -bool TryOpenDungeonWithMouse() -{ - if (leveltype != DTYPE_TOWN) - return false; - - const Item &holdItem = MyPlayer->HoldItem; - if (holdItem.IDidx == IDI_RUNEBOMB && OpensHive(cursPosition)) - OpenHive(); - else if (holdItem.IDidx == IDI_MAPOFDOOM && OpensGrave(cursPosition)) - OpenGrave(); - else - return false; - - NewCursor(CURSOR_HAND); - return true; -} - void LeftMouseDown(uint16_t modState) { LastPlayerAction = PlayerActionType::None; @@ -3508,4 +3491,21 @@ void PrintScreen(SDL_Keycode vkey) ReleaseKey(vkey); } +bool TryOpenDungeonWithMouse() +{ + if (leveltype != DTYPE_TOWN) + return false; + + const Item &holdItem = MyPlayer->HoldItem; + if (holdItem.IDidx == IDI_RUNEBOMB && OpensHive(cursPosition)) + OpenHive(); + else if (holdItem.IDidx == IDI_MAPOFDOOM && OpensGrave(cursPosition)) + OpenGrave(); + else + return false; + + NewCursor(CURSOR_HAND); + return true; +} + } // namespace devilution diff --git a/Source/diablo.h b/Source/diablo.h index c977e252b..65cb86b6a 100644 --- a/Source/diablo.h +++ b/Source/diablo.h @@ -102,6 +102,7 @@ void DisableInputEventHandler(const SDL_Event &event, uint16_t modState); tl::expected LoadGameLevel(bool firstflag, lvl_entry lvldir); bool IsDiabloAlive(bool playSFX); void PrintScreen(SDL_Keycode vkey); +bool TryOpenDungeonWithMouse(); /** * @param bStartup Process additional ticks before returning From 21e0b2fc6f281444c6463b347fc35974ea402c3f Mon Sep 17 00:00:00 2001 From: NiteKat Date: Tue, 27 Jan 2026 14:13:48 -0500 Subject: [PATCH 32/32] Add Stash Support Part 1 Adds the start of support for the API to utilize the stash. Gold deposits and withdrawl is handled, and technically the API can place and remove items from the stash; however I believe I still need to add page controls and providing the layout of the active page through the API. --- Source/dapi/Backend/Messages/game.proto | 30 +++---- Source/dapi/GameData.h | 5 +- Source/dapi/Server.cpp | 86 ++++++++++++++++++-- Source/dapi/Server.h | 102 +++++++++++++++++++++++- 4 files changed, 200 insertions(+), 23 deletions(-) diff --git a/Source/dapi/Backend/Messages/game.proto b/Source/dapi/Backend/Messages/game.proto index a5d28451e..7f3fe301e 100644 --- a/Source/dapi/Backend/Messages/game.proto +++ b/Source/dapi/Backend/Messages/game.proto @@ -20,19 +20,21 @@ message FrameUpdate { uint32 gameMode = 13; uint32 gnDifficulty = 14; uint32 connectedTo = 15; + uint32 stashGold = 16; - repeated dapi.data.TileData dPiece = 16; - repeated dapi.data.PlayerData playerData = 17; - repeated dapi.data.ItemData itemData = 18; - repeated uint32 groundItemID = 19; - repeated dapi.data.TownerData townerData = 20; - repeated uint32 storeOption = 21; - repeated uint32 storeItems = 22; - repeated dapi.data.TriggerData triggerData = 23; - repeated dapi.data.MonsterData monsterData = 24; - repeated dapi.data.ObjectData objectData = 25; - repeated dapi.data.MissileData missileData = 26; - repeated dapi.data.PortalData portalData = 27; - repeated dapi.data.QuestData questData = 28; - repeated string chatMessages = 29; + repeated dapi.data.TileData dPiece = 17; + repeated dapi.data.PlayerData playerData = 18; + repeated dapi.data.ItemData itemData = 19; + repeated uint32 groundItemID = 20; + repeated dapi.data.TownerData townerData = 21; + repeated uint32 storeOption = 22; + repeated uint32 storeItems = 23; + repeated uint32 stashItems = 24; + repeated dapi.data.TriggerData triggerData = 25; + repeated dapi.data.MonsterData monsterData = 26; + repeated dapi.data.ObjectData objectData = 27; + repeated dapi.data.MissileData missileData = 28; + repeated dapi.data.PortalData portalData = 29; + repeated dapi.data.QuestData questData = 30; + repeated string chatMessages = 31; } diff --git a/Source/dapi/GameData.h b/Source/dapi/GameData.h index 0a245483e..00cb09ae8 100644 --- a/Source/dapi/GameData.h +++ b/Source/dapi/GameData.h @@ -21,7 +21,8 @@ enum struct StoreOption { SELL, REPAIR, RECHARGE, - BACK + BACK, + ACCESSSTORAGE }; struct GameData { @@ -31,11 +32,13 @@ struct GameData { bool invflag; bool qtextflag; int currlevel; + int stashGold; size_t lastLogSize; std::map playerList; std::vector itemList; std::vector groundItems; + std::vector stashItems; std::map townerList; std::vector storeList; std::vector storeItems; diff --git a/Source/dapi/Server.cpp b/Source/dapi/Server.cpp index 6edc078aa..e8aa4992d 100644 --- a/Source/dapi/Server.cpp +++ b/Source/dapi/Server.cpp @@ -542,6 +542,8 @@ void Server::updateGameData() data->storeList.push_back(StoreOption::REPAIR); else if (!strcmp(devilution::TextLine[i].text.c_str(), "Recharge staves")) data->storeList.push_back(StoreOption::RECHARGE); + else if (!strcmp(devilution::TextLine[i].text.c_str(), "Access Storage")) + data->storeList.push_back(StoreOption::ACCESSSTORAGE); } } @@ -918,6 +920,28 @@ void Server::updateGameData() playerData->set_pmanashield(data->playerList[i].pManaShield); } + data->stashItems.clear(); + for (auto &stashItem : devilution::Stash.stashList) { + if (stashItem.isEmpty()) { + continue; + } + size_t itemID = data->itemList.size(); + for (size_t k = 0; k < data->itemList.size(); k++) { + if (data->itemList[k].compare(stashItem)) { + itemID = k; + break; + } + } + if (itemID == data->itemList.size()) + data->itemList.push_back(ItemData {}); + fullFillItemInfo(itemID, &stashItem); + data->stashItems.push_back(itemID); + update->add_stashitems(itemID); + } + + data->stashGold = devilution::Stash.gold; + update->set_stashgold(devilution::Stash.gold); + auto emptyFillItemInfo = [&](int itemID, devilution::Item *item) { itemsModified.push_back(itemID); @@ -1433,7 +1457,7 @@ void Server::selectStoreOption(StoreOption option) break; case StoreOption::WIRTPEEK: if (devilution::ActiveStore == devilution::TalkID::Boy) { - if (50 <= devilution::Players[devilution::MyPlayerId]._pGold) { + if (devilution::PlayerCanAfford(50)) { devilution::TakePlrsMoney(50); devilution::PlaySFX(devilution::SfxID::MenuSelect); devilution::StartStore(devilution::TalkID::BoyBuy); @@ -1472,6 +1496,14 @@ void Server::selectStoreOption(StoreOption option) break; } break; + case StoreOption::ACCESSSTORAGE: + if (devilution::ActiveStore != devilution::TalkID::Barmaid) + break; + devilution::ActiveStore = devilution::TalkID::None; + devilution::IsStashOpen = true; + devilution::Stash.RefreshItemStatFlags(); + devilution::invflag = true; + break; default: break; } @@ -1904,6 +1936,7 @@ void Server::toggleCharacterScreen() return; devilution::CharFlag = !devilution::CharFlag; + devilution::IsStashOpen = false; } void Server::increaseStat(CommandType commandType) @@ -2081,6 +2114,8 @@ void Server::toggleInventory() return; devilution::invflag = !devilution::invflag; + if (!devilution::invflag) + devilution::IsStashOpen = false; } void Server::putInCursor(size_t itemID) @@ -2096,7 +2131,7 @@ void Server::putInCursor(size_t itemID) mx = 0; my = 0; - for (int i = 0; i < 55; i++) { + for (int i = 0; i < 105; i++) { if (i < 7) { if (item.compare(devilution::Players[devilution::MyPlayerId].InvBody[i]) && devilution::Players[devilution::MyPlayerId].InvBody[i]._itype != devilution::ItemType::None) { if (!devilution::invflag) @@ -2152,12 +2187,33 @@ void Server::putInCursor(size_t itemID) } break; } - } else { + } else if (i < 55) { if (item.compare(devilution::Players[devilution::MyPlayerId].SpdList[i - 47]) && devilution::Players[devilution::MyPlayerId].SpdList[i - 47]._itype != devilution::ItemType::None) { mx = devilution::InvRect[i].position.x + 1 + devilution::GetMainPanel().position.x; my = devilution::InvRect[i].position.y + 1 + devilution::GetMainPanel().position.y; break; } + } else { + int j = 55; + for (auto point : devilution::StashGridRange) { + if (j != i) { + continue; + } + const devilution::StashStruct::StashCell itemId = devilution::Stash.GetItemIdAtPosition(point); + if (itemId == devilution::StashStruct::EmptyCell) { + continue; + } + devilution::Item &stashItem = devilution::Stash.stashList[itemId]; + if (stashItem.isEmpty()) { + continue; + } + if (item.compare(stashItem)) { + auto cursorPosition = devilution::GetStashSlotCoord(point); + devilution::CheckStashItem(point); + return; + } + j++; + } } } if (mx != 0 && my != 0) @@ -2185,7 +2241,10 @@ void Server::putCursorItem(int location) } if (equipLocation < EquipSlot::BELT1) { panelOffset = devilution::GetRightPanel().position - devilution::Point { 0, 0 }; - } else { + } else if (EquipSlot::BELT8 < equipLocation) { + panelOffset = devilution::GetLeftPanel().position - devilution::Point { 0, 0 }; + } + else { panelOffset = devilution::GetMainPanel().position - devilution::Point { 0, 0 }; } if (EquipSlot::INV1 <= equipLocation && equipLocation <= EquipSlot::INV40) { @@ -2197,9 +2256,22 @@ void Server::putCursorItem(int location) } else { hotPixelCellOffset = devilution::Displacement { 1, 1 }; } - - cursorPosition = devilution::InvRect[invRectIndex].position + panelOffset + hotPixelCellOffset; - devilution::CheckInvPaste(*devilution::MyPlayer, cursorPosition); + if (equipLocation < EquipSlot::STASH1) { + cursorPosition = devilution::InvRect[invRectIndex].position + panelOffset + hotPixelCellOffset; + devilution::CheckInvPaste(*devilution::MyPlayer, cursorPosition); + } else { + int i = static_cast(EquipSlot::STASH1); + for (auto point : devilution::StashGridRange) { + if (static_cast(i) != equipLocation) { + i++; + } else { + cursorPosition = devilution::GetStashSlotCoord(point); + break; + } + } + devilution::CheckStashItem(cursorPosition); + //cursorPosition = devilution::StashGridRange[invRectIndex] + panelOffset + hotPixelCellOffset; + } } void Server::dropCursorItem() diff --git a/Source/dapi/Server.h b/Source/dapi/Server.h index 31d95c51e..b698987da 100644 --- a/Source/dapi/Server.h +++ b/Source/dapi/Server.h @@ -189,7 +189,107 @@ enum struct EquipSlot { BELT5 = 51, BELT6 = 52, BELT7 = 53, - BELT8 = 54 + BELT8 = 54, + STASH1 = 55, + STASH2 = 56, + STASH3 = 57, + STASH4 = 58, + STASH5 = 59, + STASH6 = 60, + STASH7 = 61, + STASH8 = 62, + STASH9 = 63, + STASH10 = 64, + STASH11 = 65, + STASH12 = 66, + STASH13 = 67, + STASH14 = 68, + STASH15 = 69, + STASH16 = 70, + STASH17 = 71, + STASH18 = 72, + STASH19 = 73, + STASH20 = 74, + STASH21 = 75, + STASH22 = 76, + STASH23 = 77, + STASH24 = 78, + STASH25 = 79, + STASH26 = 80, + STASH27 = 81, + STASH28 = 82, + STASH29 = 83, + STASH30 = 84, + STASH31 = 85, + STASH32 = 86, + STASH33 = 87, + STASH34 = 88, + STASH35 = 89, + STASH36 = 90, + STASH37 = 91, + STASH38 = 92, + STASH39 = 93, + STASH40 = 94, + STASH41 = 95, + STASH42 = 96, + STASH43 = 97, + STASH44 = 98, + STASH45 = 99, + STASH46 = 100, + STASH47 = 101, + STASH48 = 102, + STASH49 = 103, + STASH50 = 104, + STASH51 = 105, + STASH52 = 106, + STASH53 = 107, + STASH54 = 108, + STASH55 = 109, + STASH56 = 110, + STASH57 = 111, + STASH58 = 112, + STASH59 = 113, + STASH60 = 114, + STASH61 = 115, + STASH62 = 116, + STASH63 = 117, + STASH64 = 118, + STASH65 = 119, + STASH66 = 120, + STASH67 = 121, + STASH68 = 122, + STASH69 = 123, + STASH70 = 124, + STASH71 = 125, + STASH72 = 126, + STASH73 = 127, + STASH74 = 128, + STASH75 = 129, + STASH76 = 130, + STASH77 = 131, + STASH78 = 132, + STASH79 = 133, + STASH80 = 134, + STASH81 = 135, + STASH82 = 136, + STASH83 = 137, + STASH84 = 138, + STASH85 = 139, + STASH86 = 140, + STASH87 = 141, + STASH88 = 142, + STASH89 = 143, + STASH90 = 144, + STASH91 = 145, + STASH92 = 146, + STASH93 = 147, + STASH94 = 148, + STASH95 = 149, + STASH96 = 150, + STASH97 = 151, + STASH98 = 152, + STASH99 = 153, + STASH100 = 154 }; enum struct Backend {