diff --git a/.gitignore b/.gitignore index 51f630e71..15a2aec76 100644 --- a/.gitignore +++ b/.gitignore @@ -34,7 +34,9 @@ x86/ log/ logs/ -# Proto +# Protobuf generated files +*.pb.cc +*.pb.h protobuf/csharp/* protobuf/go/* protobuf/java/* diff --git a/CMakeLists.txt b/CMakeLists.txt index e114637bf..90e0b5841 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,7 +29,7 @@ #We set a fairly new version (as of 2013) because I found finding perl was a bit... buggy on older ones #Can change this if you really want but you should upgrade! -CMAKE_MINIMUM_REQUIRED(VERSION 2.8) +CMAKE_MINIMUM_REQUIRED(VERSION 2.8.12) #FindMySQL is located here so lets make it so CMake can find it SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/" ${CMAKE_MODULE_PATH}) @@ -54,14 +54,44 @@ ENDIF(MSVC OR MINGW) # include dirs are universal SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats") -SET(PROTOBUF_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf") + +#Try to find protobuf automatically +FIND_PACKAGE(Protobuf QUIET) +IF(NOT PROTOBUF_FOUND) + SET(Protobuf_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf" CACHE PATH "Root protobuf directory" FORCE) + SET(Protobuf_PROTOC_EXECUTABLE "${Protobuf_DIR}/bin/protoc.exe" CACHE PATH "Executable path" FORCE) + SET(Protobuf_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf/include" CACHE PATH "Include dir" FORCE) + SET(Protobuf_SRC_ROOT_FOLDER "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf/include" CACHE PATH "Include dir" FORCE) + SET(PROTOBUF_FOUND TRUE CACHE BOOL "" FORCE) + + IF(NOT MSVC) + MESSAGE(STATUS "Could not find protobuf library, setting to ${Protobuf_DIR}") + ENDIF() + + IF(MSVC) + IF(CMAKE_CL_64) + SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/lib_x64/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE) + SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/lib_x64/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE) + ELSE(CMAKE_CL_64) + SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/lib_x86/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE) + SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/lib_x86/libprotobufd.lib" CACHE PATH "Root protobuf directory" FORCE) + ENDIF() + ELSE(MSVC) + SET(Protobuf_LIBRARY_DEBUG "${Protobuf_DIR}/lib_x64/libprotobuf.so.15" CACHE PATH "Root protobuf directory" FORCE) + SET(Protobuf_LIBRARY_RELEASE "${Protobuf_DIR}/lib_x64/libprotobuf.so.15" CACHE PATH "Root protobuf directory" FORCE) + ENDIF() + + #SET(Protobuf_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf/include" CACHE PATH "Include dir") + #SET(Protobuf_INCLUDE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf/include") + #SET(Protobuf_PROTOC_EXECUTABLE "${Protobuf_DIR}/bin/protoc.exe") + +ENDIF() + +INCLUDE_DIRECTORIES(SYSTEM "${Protobuf_INCLUDE_DIR}") SET(NATS_INCLUDE_DIR "${NATS_ROOT}/include") -SET(PROTOBUF_INCLUDE_DIR "${PROTOBUF_ROOT}/include") - -IF(MSVC) - +IF(MSVC) #Set our default locations for zlib/mysql based on x86/x64 IF(CMAKE_CL_64) SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x64") @@ -77,7 +107,6 @@ IF(MSVC) SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/x64/Release/v110/dynamic") ENDIF() SET(NATS_LIBRARY "${NATS_ROOT}/lib_x64/nats.lib") - SET(PROTOBUF_LIBRARY "${PROTOBUF_ROOT}/lib_x64/libprotobufd.lib") ELSE(CMAKE_CL_64) SET(ZLIB_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/zlib_x86") SET(MYSQL_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/mysql_x86") @@ -85,7 +114,6 @@ IF(MSVC) SET(SODIUM_INCLUDE_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/include") SET(OPENSSL_ROOT_DIR "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/openssl_x86") SET(NATS_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/nats_x86") - SET(PROTOBUF_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/protobuf_x86") IF(MSVC_VERSION GREATER 1800) SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v140/dynamic") ELSEIF(MSVC_VERSION EQUAL 1800) @@ -94,7 +122,6 @@ IF(MSVC) SET(SODIUM_LIBRARY_HINTS "${CMAKE_CURRENT_SOURCE_DIR}/dependencies/libsodium/Win32/Release/v110/dynamic") ENDIF() SET(NATS_LIBRARY "${NATS_ROOT}/lib_x86/nats.lib") - SET(PROTOBUF_LIBRARY "${PROTOBUF_ROOT}/lib_x86/libprotobufd.lib") ENDIF(CMAKE_CL_64) #disable CRT warnings on windows cause they're annoying as shit and we use C functions everywhere @@ -148,7 +175,6 @@ IF(MSVC) ELSE(MSVC) SET(NATS_LIBRARY "${NATS_ROOT}/lib_x64/libnats.so") - SET(PROTOBUF_LIBRARY "${PROTOBUF_ROOT}/lib_x64/libprotobuf.so.15") #Normally set by perl but we don't use the perl flags anymore so we set it. ADD_DEFINITIONS(-DHAS_UNION_SEMUN) @@ -328,7 +354,7 @@ IF(EQEMU_BUILD_PERL) INCLUDE_DIRECTORIES(SYSTEM "${PERL_INCLUDE_PATH}") ENDIF(EQEMU_BUILD_PERL) -SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt ${NATS_LIBRARY} ${PROTOBUF_LIBRARY}) +SET(SERVER_LIBS common debug ${MySQL_LIBRARY_DEBUG} optimized ${MySQL_LIBRARY_RELEASE} ${ZLIB_LIBRARY} libuv fmt ${NATS_LIBRARY} ${PROTOBUF_LIBRARY_DEBUG}) FIND_PACKAGE(Sodium REQUIRED) IF(SODIUM_FOUND) @@ -372,13 +398,14 @@ ENDIF(EQEMU_BUILD_LUA) INCLUDE_DIRECTORIES(SYSTEM "${ZLIB_INCLUDE_DIRS}") INCLUDE_DIRECTORIES(SYSTEM "${MySQL_INCLUDE_DIR}") INCLUDE_DIRECTORIES(SYSTEM "${NATS_INCLUDE_DIR}") -INCLUDE_DIRECTORIES(SYSTEM "${PROTOBUF_INCLUDE_DIR}") + INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/common/glm") INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/cereal") INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/include" ) INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/libuv/src") INCLUDE_DIRECTORIES(SYSTEM "${CMAKE_CURRENT_SOURCE_DIR}/libs/format") + IF(EQEMU_BUILD_SERVER OR EQEMU_BUILD_LOGIN OR EQEMU_BUILD_TESTS OR EQEMU_BUILD_HC) ADD_SUBDIRECTORY(common) ADD_SUBDIRECTORY(libs) diff --git a/cmake/FindPackageHandleStandardArgs.cmake b/cmake/FindPackageHandleStandardArgs.cmake new file mode 100644 index 000000000..6d8cc3ce9 --- /dev/null +++ b/cmake/FindPackageHandleStandardArgs.cmake @@ -0,0 +1,386 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#[=======================================================================[.rst: +FindPackageHandleStandardArgs +----------------------------- + +This module provides a function intended to be used in :ref:`Find Modules` +implementing :command:`find_package()` calls. It handles the +``REQUIRED``, ``QUIET`` and version-related arguments of ``find_package``. +It also sets the ``_FOUND`` variable. The package is +considered found if all variables listed contain valid results, e.g. +valid filepaths. + +.. command:: find_package_handle_standard_args + + There are two signatures:: + + find_package_handle_standard_args( + (DEFAULT_MSG|) + ... + ) + + find_package_handle_standard_args( + [FOUND_VAR ] + [REQUIRED_VARS ...] + [VERSION_VAR ] + [HANDLE_COMPONENTS] + [CONFIG_MODE] + [FAIL_MESSAGE ] + ) + + The ``_FOUND`` variable will be set to ``TRUE`` if all + the variables ``...`` are valid and any optional + constraints are satisfied, and ``FALSE`` otherwise. A success or + failure message may be displayed based on the results and on + whether the ``REQUIRED`` and/or ``QUIET`` option was given to + the :command:`find_package` call. + + The options are: + + ``(DEFAULT_MSG|)`` + In the simple signature this specifies the failure message. + Use ``DEFAULT_MSG`` to ask for a default message to be computed + (recommended). Not valid in the full signature. + + ``FOUND_VAR `` + Obsolete. Specifies either ``_FOUND`` or + ``_FOUND`` as the result variable. This exists only + for compatibility with older versions of CMake and is now ignored. + Result variables of both names are always set for compatibility. + + ``REQUIRED_VARS ...`` + Specify the variables which are required for this package. + These may be named in the generated failure message asking the + user to set the missing variable values. Therefore these should + typically be cache entries such as ``FOO_LIBRARY`` and not output + variables like ``FOO_LIBRARIES``. + + ``VERSION_VAR `` + Specify the name of a variable that holds the version of the package + that has been found. This version will be checked against the + (potentially) specified required version given to the + :command:`find_package` call, including its ``EXACT`` option. + The default messages include information about the required + version and the version which has been actually found, both + if the version is ok or not. + + ``HANDLE_COMPONENTS`` + Enable handling of package components. In this case, the command + will report which components have been found and which are missing, + and the ``_FOUND`` variable will be set to ``FALSE`` + if any of the required components (i.e. not the ones listed after + the ``OPTIONAL_COMPONENTS`` option of :command:`find_package`) are + missing. + + ``CONFIG_MODE`` + Specify that the calling find module is a wrapper around a + call to ``find_package( NO_MODULE)``. This implies + a ``VERSION_VAR`` value of ``_VERSION``. The command + will automatically check whether the package configuration file + was found. + + ``FAIL_MESSAGE `` + Specify a custom failure message instead of using the default + generated message. Not recommended. + +Example for the simple signature: + +.. code-block:: cmake + + find_package_handle_standard_args(LibXml2 DEFAULT_MSG + LIBXML2_LIBRARY LIBXML2_INCLUDE_DIR) + +The ``LibXml2`` package is considered to be found if both +``LIBXML2_LIBRARY`` and ``LIBXML2_INCLUDE_DIR`` are valid. +Then also ``LibXml2_FOUND`` is set to ``TRUE``. If it is not found +and ``REQUIRED`` was used, it fails with a +:command:`message(FATAL_ERROR)`, independent whether ``QUIET`` was +used or not. If it is found, success will be reported, including +the content of the first ````. On repeated CMake runs, +the same message will not be printed again. + +Example for the full signature: + +.. code-block:: cmake + + find_package_handle_standard_args(LibArchive + REQUIRED_VARS LibArchive_LIBRARY LibArchive_INCLUDE_DIR + VERSION_VAR LibArchive_VERSION) + +In this case, the ``LibArchive`` package is considered to be found if +both ``LibArchive_LIBRARY`` and ``LibArchive_INCLUDE_DIR`` are valid. +Also the version of ``LibArchive`` will be checked by using the version +contained in ``LibArchive_VERSION``. Since no ``FAIL_MESSAGE`` is given, +the default messages will be printed. + +Another example for the full signature: + +.. code-block:: cmake + + find_package(Automoc4 QUIET NO_MODULE HINTS /opt/automoc4) + find_package_handle_standard_args(Automoc4 CONFIG_MODE) + +In this case, a ``FindAutmoc4.cmake`` module wraps a call to +``find_package(Automoc4 NO_MODULE)`` and adds an additional search +directory for ``automoc4``. Then the call to +``find_package_handle_standard_args`` produces a proper success/failure +message. +#]=======================================================================] + +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageMessage.cmake) + +# internal helper macro +macro(_FPHSA_FAILURE_MESSAGE _msg) + if (${_NAME}_FIND_REQUIRED) + message(FATAL_ERROR "${_msg}") + else () + if (NOT ${_NAME}_FIND_QUIETLY) + message(STATUS "${_msg}") + endif () + endif () +endmacro() + + +# internal helper macro to generate the failure message when used in CONFIG_MODE: +macro(_FPHSA_HANDLE_FAILURE_CONFIG_MODE) + # _CONFIG is set, but FOUND is false, this means that some other of the REQUIRED_VARS was not found: + if(${_NAME}_CONFIG) + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: missing:${MISSING_VARS} (found ${${_NAME}_CONFIG} ${VERSION_MSG})") + else() + # If _CONSIDERED_CONFIGS is set, the config-file has been found, but no suitable version. + # List them all in the error message: + if(${_NAME}_CONSIDERED_CONFIGS) + set(configsText "") + list(LENGTH ${_NAME}_CONSIDERED_CONFIGS configsCount) + math(EXPR configsCount "${configsCount} - 1") + foreach(currentConfigIndex RANGE ${configsCount}) + list(GET ${_NAME}_CONSIDERED_CONFIGS ${currentConfigIndex} filename) + list(GET ${_NAME}_CONSIDERED_VERSIONS ${currentConfigIndex} version) + string(APPEND configsText " ${filename} (version ${version})\n") + endforeach() + if (${_NAME}_NOT_FOUND_MESSAGE) + string(APPEND configsText " Reason given by package: ${${_NAME}_NOT_FOUND_MESSAGE}\n") + endif() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} ${VERSION_MSG}, checked the following files:\n${configsText}") + + else() + # Simple case: No Config-file was found at all: + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: found neither ${_NAME}Config.cmake nor ${_NAME_LOWER}-config.cmake ${VERSION_MSG}") + endif() + endif() +endmacro() + + +function(FIND_PACKAGE_HANDLE_STANDARD_ARGS _NAME _FIRST_ARG) + +# Set up the arguments for `cmake_parse_arguments`. + set(options CONFIG_MODE HANDLE_COMPONENTS) + set(oneValueArgs FAIL_MESSAGE VERSION_VAR FOUND_VAR) + set(multiValueArgs REQUIRED_VARS) + +# Check whether we are in 'simple' or 'extended' mode: + set(_KEYWORDS_FOR_EXTENDED_MODE ${options} ${oneValueArgs} ${multiValueArgs} ) + list(FIND _KEYWORDS_FOR_EXTENDED_MODE "${_FIRST_ARG}" INDEX) + + if(${INDEX} EQUAL -1) + set(FPHSA_FAIL_MESSAGE ${_FIRST_ARG}) + set(FPHSA_REQUIRED_VARS ${ARGN}) + set(FPHSA_VERSION_VAR) + else() + cmake_parse_arguments(FPHSA "${options}" "${oneValueArgs}" "${multiValueArgs}" ${_FIRST_ARG} ${ARGN}) + + if(FPHSA_UNPARSED_ARGUMENTS) + message(FATAL_ERROR "Unknown keywords given to FIND_PACKAGE_HANDLE_STANDARD_ARGS(): \"${FPHSA_UNPARSED_ARGUMENTS}\"") + endif() + + if(NOT FPHSA_FAIL_MESSAGE) + set(FPHSA_FAIL_MESSAGE "DEFAULT_MSG") + endif() + + # In config-mode, we rely on the variable _CONFIG, which is set by find_package() + # when it successfully found the config-file, including version checking: + if(FPHSA_CONFIG_MODE) + list(INSERT FPHSA_REQUIRED_VARS 0 ${_NAME}_CONFIG) + list(REMOVE_DUPLICATES FPHSA_REQUIRED_VARS) + set(FPHSA_VERSION_VAR ${_NAME}_VERSION) + endif() + + if(NOT FPHSA_REQUIRED_VARS) + message(FATAL_ERROR "No REQUIRED_VARS specified for FIND_PACKAGE_HANDLE_STANDARD_ARGS()") + endif() + endif() + +# now that we collected all arguments, process them + + if("x${FPHSA_FAIL_MESSAGE}" STREQUAL "xDEFAULT_MSG") + set(FPHSA_FAIL_MESSAGE "Could NOT find ${_NAME}") + endif() + + list(GET FPHSA_REQUIRED_VARS 0 _FIRST_REQUIRED_VAR) + + string(TOUPPER ${_NAME} _NAME_UPPER) + string(TOLOWER ${_NAME} _NAME_LOWER) + + if(FPHSA_FOUND_VAR) + if(FPHSA_FOUND_VAR MATCHES "^${_NAME}_FOUND$" OR FPHSA_FOUND_VAR MATCHES "^${_NAME_UPPER}_FOUND$") + set(_FOUND_VAR ${FPHSA_FOUND_VAR}) + else() + message(FATAL_ERROR "The argument for FOUND_VAR is \"${FPHSA_FOUND_VAR}\", but only \"${_NAME}_FOUND\" and \"${_NAME_UPPER}_FOUND\" are valid names.") + endif() + else() + set(_FOUND_VAR ${_NAME_UPPER}_FOUND) + endif() + + # collect all variables which were not found, so they can be printed, so the + # user knows better what went wrong (#6375) + set(MISSING_VARS "") + set(DETAILS "") + # check if all passed variables are valid + set(FPHSA_FOUND_${_NAME} TRUE) + foreach(_CURRENT_VAR ${FPHSA_REQUIRED_VARS}) + if(NOT ${_CURRENT_VAR}) + set(FPHSA_FOUND_${_NAME} FALSE) + string(APPEND MISSING_VARS " ${_CURRENT_VAR}") + else() + string(APPEND DETAILS "[${${_CURRENT_VAR}}]") + endif() + endforeach() + if(FPHSA_FOUND_${_NAME}) + set(${_NAME}_FOUND TRUE) + set(${_NAME_UPPER}_FOUND TRUE) + else() + set(${_NAME}_FOUND FALSE) + set(${_NAME_UPPER}_FOUND FALSE) + endif() + + # component handling + unset(FOUND_COMPONENTS_MSG) + unset(MISSING_COMPONENTS_MSG) + + if(FPHSA_HANDLE_COMPONENTS) + foreach(comp ${${_NAME}_FIND_COMPONENTS}) + if(${_NAME}_${comp}_FOUND) + + if(NOT DEFINED FOUND_COMPONENTS_MSG) + set(FOUND_COMPONENTS_MSG "found components: ") + endif() + string(APPEND FOUND_COMPONENTS_MSG " ${comp}") + + else() + + if(NOT DEFINED MISSING_COMPONENTS_MSG) + set(MISSING_COMPONENTS_MSG "missing components: ") + endif() + string(APPEND MISSING_COMPONENTS_MSG " ${comp}") + + if(${_NAME}_FIND_REQUIRED_${comp}) + set(${_NAME}_FOUND FALSE) + string(APPEND MISSING_VARS " ${comp}") + endif() + + endif() + endforeach() + set(COMPONENT_MSG "${FOUND_COMPONENTS_MSG} ${MISSING_COMPONENTS_MSG}") + string(APPEND DETAILS "[c${COMPONENT_MSG}]") + endif() + + # version handling: + set(VERSION_MSG "") + set(VERSION_OK TRUE) + + # check with DEFINED here as the requested or found version may be "0" + if (DEFINED ${_NAME}_FIND_VERSION) + if(DEFINED ${FPHSA_VERSION_VAR}) + set(_FOUND_VERSION ${${FPHSA_VERSION_VAR}}) + + if(${_NAME}_FIND_VERSION_EXACT) # exact version required + # count the dots in the version string + string(REGEX REPLACE "[^.]" "" _VERSION_DOTS "${_FOUND_VERSION}") + # add one dot because there is one dot more than there are components + string(LENGTH "${_VERSION_DOTS}." _VERSION_DOTS) + if (_VERSION_DOTS GREATER ${_NAME}_FIND_VERSION_COUNT) + # Because of the C++ implementation of find_package() ${_NAME}_FIND_VERSION_COUNT + # is at most 4 here. Therefore a simple lookup table is used. + if (${_NAME}_FIND_VERSION_COUNT EQUAL 1) + set(_VERSION_REGEX "[^.]*") + elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 2) + set(_VERSION_REGEX "[^.]*\\.[^.]*") + elseif (${_NAME}_FIND_VERSION_COUNT EQUAL 3) + set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*") + else () + set(_VERSION_REGEX "[^.]*\\.[^.]*\\.[^.]*\\.[^.]*") + endif () + string(REGEX REPLACE "^(${_VERSION_REGEX})\\..*" "\\1" _VERSION_HEAD "${_FOUND_VERSION}") + unset(_VERSION_REGEX) + if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _VERSION_HEAD) + set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") + set(VERSION_OK FALSE) + else () + set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")") + endif () + unset(_VERSION_HEAD) + else () + if (NOT ${_NAME}_FIND_VERSION VERSION_EQUAL _FOUND_VERSION) + set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is exact version \"${${_NAME}_FIND_VERSION}\"") + set(VERSION_OK FALSE) + else () + set(VERSION_MSG "(found suitable exact version \"${_FOUND_VERSION}\")") + endif () + endif () + unset(_VERSION_DOTS) + + else() # minimum version specified: + if (${_NAME}_FIND_VERSION VERSION_GREATER _FOUND_VERSION) + set(VERSION_MSG "Found unsuitable version \"${_FOUND_VERSION}\", but required is at least \"${${_NAME}_FIND_VERSION}\"") + set(VERSION_OK FALSE) + else () + set(VERSION_MSG "(found suitable version \"${_FOUND_VERSION}\", minimum required is \"${${_NAME}_FIND_VERSION}\")") + endif () + endif() + + else() + + # if the package was not found, but a version was given, add that to the output: + if(${_NAME}_FIND_VERSION_EXACT) + set(VERSION_MSG "(Required is exact version \"${${_NAME}_FIND_VERSION}\")") + else() + set(VERSION_MSG "(Required is at least version \"${${_NAME}_FIND_VERSION}\")") + endif() + + endif() + else () + # Check with DEFINED as the found version may be 0. + if(DEFINED ${FPHSA_VERSION_VAR}) + set(VERSION_MSG "(found version \"${${FPHSA_VERSION_VAR}}\")") + endif() + endif () + + if(VERSION_OK) + string(APPEND DETAILS "[v${${FPHSA_VERSION_VAR}}(${${_NAME}_FIND_VERSION})]") + else() + set(${_NAME}_FOUND FALSE) + endif() + + + # print the result: + if (${_NAME}_FOUND) + FIND_PACKAGE_MESSAGE(${_NAME} "Found ${_NAME}: ${${_FIRST_REQUIRED_VAR}} ${VERSION_MSG} ${COMPONENT_MSG}" "${DETAILS}") + else () + + if(FPHSA_CONFIG_MODE) + _FPHSA_HANDLE_FAILURE_CONFIG_MODE() + else() + if(NOT VERSION_OK) + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE}: ${VERSION_MSG} (found ${${_FIRST_REQUIRED_VAR}})") + else() + _FPHSA_FAILURE_MESSAGE("${FPHSA_FAIL_MESSAGE} (missing:${MISSING_VARS}) ${VERSION_MSG}") + endif() + endif() + + endif () + + set(${_NAME}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) + set(${_NAME_UPPER}_FOUND ${${_NAME}_FOUND} PARENT_SCOPE) +endfunction() \ No newline at end of file diff --git a/cmake/FindPackageMessage.cmake b/cmake/FindPackageMessage.cmake new file mode 100644 index 000000000..912d7916f --- /dev/null +++ b/cmake/FindPackageMessage.cmake @@ -0,0 +1,47 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#.rst: +# FindPackageMessage +# ------------------ +# +# +# +# FIND_PACKAGE_MESSAGE( "message for user" "find result details") +# +# This macro is intended to be used in FindXXX.cmake modules files. It +# will print a message once for each unique find result. This is useful +# for telling the user where a package was found. The first argument +# specifies the name (XXX) of the package. The second argument +# specifies the message to display. The third argument lists details +# about the find result so that if they change the message will be +# displayed again. The macro also obeys the QUIET argument to the +# find_package command. +# +# Example: +# +# :: +# +# if(X11_FOUND) +# FIND_PACKAGE_MESSAGE(X11 "Found X11: ${X11_X11_LIB}" +# "[${X11_X11_LIB}][${X11_INCLUDE_DIR}]") +# else() +# ... +# endif() + +function(FIND_PACKAGE_MESSAGE pkg msg details) + # Avoid printing a message repeatedly for the same find result. + if(NOT ${pkg}_FIND_QUIETLY) + string(REPLACE "\n" "" details "${details}") + set(DETAILS_VAR FIND_PACKAGE_MESSAGE_DETAILS_${pkg}) + if(NOT "${details}" STREQUAL "${${DETAILS_VAR}}") + # The message has not yet been printed. + message(STATUS "${msg}") + + # Save the find details in the cache to avoid printing the same + # message again. + set("${DETAILS_VAR}" "${details}" + CACHE INTERNAL "Details about finding ${pkg}") + endif() + endif() +endfunction() \ No newline at end of file diff --git a/cmake/FindProtobuf.cmake b/cmake/FindProtobuf.cmake new file mode 100644 index 000000000..d73480eb5 --- /dev/null +++ b/cmake/FindProtobuf.cmake @@ -0,0 +1,579 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#.rst: +# FindProtobuf +# ------------ +# +# Locate and configure the Google Protocol Buffers library. +# +# The following variables can be set and are optional: +# +# ``Protobuf_SRC_ROOT_FOLDER`` +# When compiling with MSVC, if this cache variable is set +# the protobuf-default VS project build locations +# (vsprojects/Debug and vsprojects/Release +# or vsprojects/x64/Debug and vsprojects/x64/Release) +# will be searched for libraries and binaries. +# ``Protobuf_IMPORT_DIRS`` +# List of additional directories to be searched for +# imported .proto files. +# ``Protobuf_DEBUG`` +# Show debug messages. +# ``Protobuf_USE_STATIC_LIBS`` +# Set to ON to force the use of the static libraries. +# Default is OFF. +# +# Defines the following variables: +# +# ``Protobuf_FOUND`` +# Found the Google Protocol Buffers library +# (libprotobuf & header files) +# ``Protobuf_VERSION`` +# Version of package found. +# ``Protobuf_INCLUDE_DIRS`` +# Include directories for Google Protocol Buffers +# ``Protobuf_LIBRARIES`` +# The protobuf libraries +# ``Protobuf_PROTOC_LIBRARIES`` +# The protoc libraries +# ``Protobuf_LITE_LIBRARIES`` +# The protobuf-lite libraries +# +# The following :prop_tgt:`IMPORTED` targets are also defined: +# +# ``protobuf::libprotobuf`` +# The protobuf library. +# ``protobuf::libprotobuf-lite`` +# The protobuf lite library. +# ``protobuf::libprotoc`` +# The protoc library. +# ``protobuf::protoc`` +# The protoc compiler. +# +# The following cache variables are also available to set or use: +# +# ``Protobuf_LIBRARY`` +# The protobuf library +# ``Protobuf_PROTOC_LIBRARY`` +# The protoc library +# ``Protobuf_INCLUDE_DIR`` +# The include directory for protocol buffers +# ``Protobuf_PROTOC_EXECUTABLE`` +# The protoc compiler +# ``Protobuf_LIBRARY_DEBUG`` +# The protobuf library (debug) +# ``Protobuf_PROTOC_LIBRARY_DEBUG`` +# The protoc library (debug) +# ``Protobuf_LITE_LIBRARY`` +# The protobuf lite library +# ``Protobuf_LITE_LIBRARY_DEBUG`` +# The protobuf lite library (debug) +# +# Example: +# +# .. code-block:: cmake +# +# find_package(Protobuf REQUIRED) +# include_directories(${Protobuf_INCLUDE_DIRS}) +# include_directories(${CMAKE_CURRENT_BINARY_DIR}) +# protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS foo.proto) +# protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS EXPORT_MACRO DLL_EXPORT foo.proto) +# protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS DESCRIPTORS PROTO_DESCS foo.proto) +# protobuf_generate_python(PROTO_PY foo.proto) +# add_executable(bar bar.cc ${PROTO_SRCS} ${PROTO_HDRS}) +# target_link_libraries(bar ${Protobuf_LIBRARIES}) +# +# .. note:: +# The ``protobuf_generate_cpp`` and ``protobuf_generate_python`` +# functions and :command:`add_executable` or :command:`add_library` +# calls only work properly within the same directory. +# +# .. command:: protobuf_generate_cpp +# +# Add custom commands to process ``.proto`` files to C++:: +# +# protobuf_generate_cpp ( +# [DESCRIPTORS ] [EXPORT_MACRO ] [...]) +# +# ``SRCS`` +# Variable to define with autogenerated source files +# ``HDRS`` +# Variable to define with autogenerated header files +# ``DESCRIPTORS`` +# Variable to define with autogenerated descriptor files, if requested. +# ``EXPORT_MACRO`` +# is a macro which should expand to ``__declspec(dllexport)`` or +# ``__declspec(dllimport)`` depending on what is being compiled. +# ``ARGN`` +# ``.proto`` files +# +# .. command:: protobuf_generate_python +# +# Add custom commands to process ``.proto`` files to Python:: +# +# protobuf_generate_python ( [...]) +# +# ``PY`` +# Variable to define with autogenerated Python files +# ``ARGN`` +# ``.proto`` filess + +function(PROTOBUF_GENERATE_CPP SRCS HDRS) + cmake_parse_arguments(protobuf "" "EXPORT_MACRO;DESCRIPTORS" "" ${ARGN}) + + set(PROTO_FILES "${protobuf_UNPARSED_ARGUMENTS}") + if(NOT PROTO_FILES) + message(SEND_ERROR "Error: PROTOBUF_GENERATE_CPP() called without any proto files") + return() + endif() + + if(protobuf_EXPORT_MACRO) + set(DLL_EXPORT_DECL "dllexport_decl=${protobuf_EXPORT_MACRO}:") + endif() + + if(PROTOBUF_GENERATE_CPP_APPEND_PATH) + # Create an include path for each file specified + foreach(FIL ${PROTO_FILES}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(ABS_PATH ${ABS_FIL} PATH) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + else() + set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + + if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS) + set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}") + endif() + + if(DEFINED Protobuf_IMPORT_DIRS) + foreach(DIR ${Protobuf_IMPORT_DIRS}) + get_filename_component(ABS_PATH ${DIR} ABSOLUTE) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + endif() + + set(${SRCS}) + set(${HDRS}) + if (protobuf_DESCRIPTORS) + set(${protobuf_DESCRIPTORS}) + endif() + + foreach(FIL ${PROTO_FILES}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(FIL_WE ${FIL} NAME_WE) + if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH) + get_filename_component(FIL_DIR ${FIL} DIRECTORY) + if(FIL_DIR) + set(FIL_WE "${FIL_DIR}/${FIL_WE}") + endif() + endif() + + set(_protobuf_protoc_src "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.cc") + set(_protobuf_protoc_hdr "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.pb.h") + list(APPEND ${SRCS} "${_protobuf_protoc_src}") + list(APPEND ${HDRS} "${_protobuf_protoc_hdr}") + + if(protobuf_DESCRIPTORS) + set(_protobuf_protoc_desc "${CMAKE_CURRENT_SOURCE_DIR}/${FIL_WE}.desc") + set(_protobuf_protoc_flags "--descriptor_set_out=${_protobuf_protoc_desc}") + list(APPEND ${protobuf_DESCRIPTORS} "${_protobuf_protoc_desc}") + else() + set(_protobuf_protoc_desc "") + set(_protobuf_protoc_flags "") + endif() + + add_custom_command( + OUTPUT "${_protobuf_protoc_src}" + "${_protobuf_protoc_hdr}" + ${_protobuf_protoc_desc} + COMMAND protobuf::protoc + "--cpp_out=${DLL_EXPORT_DECL}${CMAKE_CURRENT_SOURCE_DIR}" + ${_protobuf_protoc_flags} + ${_protobuf_include_path} ${ABS_FIL} + DEPENDS ${ABS_FIL} protobuf::protoc + COMMENT "Running C++ protocol buffer compiler on ${FIL}" + VERBATIM ) + endforeach() + + set(${SRCS} "${${SRCS}}" PARENT_SCOPE) + set(${HDRS} "${${HDRS}}" PARENT_SCOPE) + if(protobuf_DESCRIPTORS) + set(${protobuf_DESCRIPTORS} "${${protobuf_DESCRIPTORS}}" PARENT_SCOPE) + endif() + +endfunction() + +function(PROTOBUF_GENERATE_PYTHON SRCS) + if(NOT ARGN) + message(SEND_ERROR "Error: PROTOBUF_GENERATE_PYTHON() called without any proto files") + return() + endif() + + if(PROTOBUF_GENERATE_CPP_APPEND_PATH) + # Create an include path for each file specified + foreach(FIL ${ARGN}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(ABS_PATH ${ABS_FIL} PATH) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + else() + set(_protobuf_include_path -I ${CMAKE_CURRENT_SOURCE_DIR}) + endif() + + if(DEFINED PROTOBUF_IMPORT_DIRS AND NOT DEFINED Protobuf_IMPORT_DIRS) + set(Protobuf_IMPORT_DIRS "${PROTOBUF_IMPORT_DIRS}") + endif() + + if(DEFINED Protobuf_IMPORT_DIRS) + foreach(DIR ${Protobuf_IMPORT_DIRS}) + get_filename_component(ABS_PATH ${DIR} ABSOLUTE) + list(FIND _protobuf_include_path ${ABS_PATH} _contains_already) + if(${_contains_already} EQUAL -1) + list(APPEND _protobuf_include_path -I ${ABS_PATH}) + endif() + endforeach() + endif() + + set(${SRCS}) + foreach(FIL ${ARGN}) + get_filename_component(ABS_FIL ${FIL} ABSOLUTE) + get_filename_component(FIL_WE ${FIL} NAME_WE) + if(NOT PROTOBUF_GENERATE_CPP_APPEND_PATH) + get_filename_component(FIL_DIR ${FIL} DIRECTORY) + if(FIL_DIR) + set(FIL_WE "${FIL_DIR}/${FIL_WE}") + endif() + endif() + + list(APPEND ${SRCS} "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py") + add_custom_command( + OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/${FIL_WE}_pb2.py" + COMMAND protobuf::protoc --python_out ${CMAKE_CURRENT_BINARY_DIR} ${_protobuf_include_path} ${ABS_FIL} + DEPENDS ${ABS_FIL} protobuf::protoc + COMMENT "Running Python protocol buffer compiler on ${FIL}" + VERBATIM ) + endforeach() + + set(${SRCS} ${${SRCS}} PARENT_SCOPE) +endfunction() + + +if(Protobuf_DEBUG) + # Output some of their choices + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "Protobuf_USE_STATIC_LIBS = ${Protobuf_USE_STATIC_LIBS}") +endif() + + +# Backwards compatibility +# Define camel case versions of input variables +foreach(UPPER + PROTOBUF_SRC_ROOT_FOLDER + PROTOBUF_IMPORT_DIRS + PROTOBUF_DEBUG + PROTOBUF_LIBRARY + PROTOBUF_PROTOC_LIBRARY + PROTOBUF_INCLUDE_DIR + PROTOBUF_PROTOC_EXECUTABLE + PROTOBUF_LIBRARY_DEBUG + PROTOBUF_PROTOC_LIBRARY_DEBUG + PROTOBUF_LITE_LIBRARY + PROTOBUF_LITE_LIBRARY_DEBUG + ) + if (DEFINED ${UPPER}) + string(REPLACE "PROTOBUF_" "Protobuf_" Camel ${UPPER}) + if (NOT DEFINED ${Camel}) + set(${Camel} ${${UPPER}}) + endif() + endif() +endforeach() + +if(CMAKE_SIZEOF_VOID_P EQUAL 8) + set(_PROTOBUF_ARCH_DIR x64/) +endif() + + +# Support preference of static libs by adjusting CMAKE_FIND_LIBRARY_SUFFIXES +if( Protobuf_USE_STATIC_LIBS ) + set( _protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES ${CMAKE_FIND_LIBRARY_SUFFIXES}) + if(WIN32) + set(CMAKE_FIND_LIBRARY_SUFFIXES .lib .a ${CMAKE_FIND_LIBRARY_SUFFIXES}) + else() + set(CMAKE_FIND_LIBRARY_SUFFIXES .a ) + endif() +endif() + +include(${CMAKE_CURRENT_LIST_DIR}/SelectLibraryConfigurations.cmake) + +# Internal function: search for normal library as well as a debug one +# if the debug one is specified also include debug/optimized keywords +# in *_LIBRARIES variable +function(_protobuf_find_libraries name filename) + if(${name}_LIBRARIES) + # Use result recorded by a previous call. + return() + elseif(${name}_LIBRARY) + # Honor cache entry used by CMake 3.5 and lower. + set(${name}_LIBRARIES "${${name}_LIBRARY}" PARENT_SCOPE) + else() + find_library(${name}_LIBRARY_RELEASE + NAMES ${filename} + PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release) + mark_as_advanced(${name}_LIBRARY_RELEASE) + + find_library(${name}_LIBRARY_DEBUG + NAMES ${filename}d ${filename} + PATHS ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug) + mark_as_advanced(${name}_LIBRARY_DEBUG) + + select_library_configurations(${name}) + set(${name}_LIBRARY "${${name}_LIBRARY}" PARENT_SCOPE) + set(${name}_LIBRARIES "${${name}_LIBRARIES}" PARENT_SCOPE) + endif() +endfunction() + +# Internal function: find threads library +function(_protobuf_find_threads) + set(CMAKE_THREAD_PREFER_PTHREAD TRUE) + find_package(Threads) + if(Threads_FOUND) + list(APPEND Protobuf_LIBRARIES ${CMAKE_THREAD_LIBS_INIT}) + set(Protobuf_LIBRARIES "${Protobuf_LIBRARIES}" PARENT_SCOPE) + endif() +endfunction() + +# +# Main. +# + +# By default have PROTOBUF_GENERATE_CPP macro pass -I to protoc +# for each directory where a proto file is referenced. +if(NOT DEFINED PROTOBUF_GENERATE_CPP_APPEND_PATH) + set(PROTOBUF_GENERATE_CPP_APPEND_PATH TRUE) +endif() + + +# Google's provided vcproj files generate libraries with a "lib" +# prefix on Windows +if(MSVC) + set(Protobuf_ORIG_FIND_LIBRARY_PREFIXES "${CMAKE_FIND_LIBRARY_PREFIXES}") + set(CMAKE_FIND_LIBRARY_PREFIXES "lib" "") + + find_path(Protobuf_SRC_ROOT_FOLDER protobuf.pc.in) +endif() + +# The Protobuf library +_protobuf_find_libraries(Protobuf protobuf) +#DOC "The Google Protocol Buffers RELEASE Library" + +_protobuf_find_libraries(Protobuf_LITE protobuf-lite) + +# The Protobuf Protoc Library +_protobuf_find_libraries(Protobuf_PROTOC protoc) + +# Restore original find library prefixes +if(MSVC) + set(CMAKE_FIND_LIBRARY_PREFIXES "${Protobuf_ORIG_FIND_LIBRARY_PREFIXES}") +endif() + +if(UNIX) + _protobuf_find_threads() +endif() + +# Find the include directory +find_path(Protobuf_INCLUDE_DIR + google/protobuf/service.h + PATHS ${Protobuf_SRC_ROOT_FOLDER}/src +) +mark_as_advanced(Protobuf_INCLUDE_DIR) + +# Find the protoc Executable +find_program(Protobuf_PROTOC_EXECUTABLE + NAMES protoc + DOC "The Google Protocol Buffers Compiler" + PATHS + ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Release + ${Protobuf_SRC_ROOT_FOLDER}/vsprojects/${_PROTOBUF_ARCH_DIR}Debug +) +mark_as_advanced(Protobuf_PROTOC_EXECUTABLE) + +if(Protobuf_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "requested version of Google Protobuf is ${Protobuf_FIND_VERSION}") +endif() + +if(Protobuf_INCLUDE_DIR) + set(_PROTOBUF_COMMON_HEADER ${Protobuf_INCLUDE_DIR}/google/protobuf/stubs/common.h) + + if(Protobuf_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "location of common.h: ${_PROTOBUF_COMMON_HEADER}") + endif() + + set(Protobuf_VERSION "") + set(Protobuf_LIB_VERSION "") + file(STRINGS ${_PROTOBUF_COMMON_HEADER} _PROTOBUF_COMMON_H_CONTENTS REGEX "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+") + if(_PROTOBUF_COMMON_H_CONTENTS MATCHES "#define[ \t]+GOOGLE_PROTOBUF_VERSION[ \t]+([0-9]+)") + set(Protobuf_LIB_VERSION "${CMAKE_MATCH_1}") + endif() + unset(_PROTOBUF_COMMON_H_CONTENTS) + + math(EXPR _PROTOBUF_MAJOR_VERSION "${Protobuf_LIB_VERSION} / 1000000") + math(EXPR _PROTOBUF_MINOR_VERSION "${Protobuf_LIB_VERSION} / 1000 % 1000") + math(EXPR _PROTOBUF_SUBMINOR_VERSION "${Protobuf_LIB_VERSION} % 1000") + set(Protobuf_VERSION "${_PROTOBUF_MAJOR_VERSION}.${_PROTOBUF_MINOR_VERSION}.${_PROTOBUF_SUBMINOR_VERSION}") + + if(Protobuf_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "${_PROTOBUF_COMMON_HEADER} reveals protobuf ${Protobuf_VERSION}") + endif() + + # Check Protobuf compiler version to be aligned with libraries version + execute_process(COMMAND ${Protobuf_PROTOC_EXECUTABLE} --version + OUTPUT_VARIABLE _PROTOBUF_PROTOC_EXECUTABLE_VERSION) + + if("${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" MATCHES "libprotoc ([0-9.]+)") + set(_PROTOBUF_PROTOC_EXECUTABLE_VERSION "${CMAKE_MATCH_1}") + endif() + + if(Protobuf_DEBUG) + message(STATUS "[ ${CMAKE_CURRENT_LIST_FILE}:${CMAKE_CURRENT_LIST_LINE} ] " + "${Protobuf_PROTOC_EXECUTABLE} reveals version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}") + endif() + + if(NOT "${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" VERSION_EQUAL "${Protobuf_VERSION}") + message(WARNING "Protobuf compiler version ${_PROTOBUF_PROTOC_EXECUTABLE_VERSION}" + " doesn't match library version ${Protobuf_VERSION}") + endif() + + if(Protobuf_LIBRARY) + if(NOT TARGET protobuf::libprotobuf) + add_library(protobuf::libprotobuf UNKNOWN IMPORTED) + set_target_properties(protobuf::libprotobuf PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}") + if(EXISTS "${Protobuf_LIBRARY}") + set_target_properties(protobuf::libprotobuf PROPERTIES + IMPORTED_LOCATION "${Protobuf_LIBRARY}") + endif() + if(EXISTS "${Protobuf_LIBRARY_RELEASE}") + set_property(TARGET protobuf::libprotobuf APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(protobuf::libprotobuf PROPERTIES + IMPORTED_LOCATION_RELEASE "${Protobuf_LIBRARY_RELEASE}") + endif() + if(EXISTS "${Protobuf_LIBRARY_DEBUG}") + set_property(TARGET protobuf::libprotobuf APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(protobuf::libprotobuf PROPERTIES + IMPORTED_LOCATION_DEBUG "${Protobuf_LIBRARY_DEBUG}") + endif() + endif() + endif() + + if(Protobuf_LITE_LIBRARY) + if(NOT TARGET protobuf::libprotobuf-lite) + add_library(protobuf::libprotobuf-lite UNKNOWN IMPORTED) + set_target_properties(protobuf::libprotobuf-lite PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}") + if(EXISTS "${Protobuf_LITE_LIBRARY}") + set_target_properties(protobuf::libprotobuf-lite PROPERTIES + IMPORTED_LOCATION "${Protobuf_LITE_LIBRARY}") + endif() + if(EXISTS "${Protobuf_LITE_LIBRARY_RELEASE}") + set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(protobuf::libprotobuf-lite PROPERTIES + IMPORTED_LOCATION_RELEASE "${Protobuf_LITE_LIBRARY_RELEASE}") + endif() + if(EXISTS "${Protobuf_LITE_LIBRARY_DEBUG}") + set_property(TARGET protobuf::libprotobuf-lite APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(protobuf::libprotobuf-lite PROPERTIES + IMPORTED_LOCATION_DEBUG "${Protobuf_LITE_LIBRARY_DEBUG}") + endif() + endif() + endif() + + if(Protobuf_PROTOC_LIBRARY) + if(NOT TARGET protobuf::libprotoc) + add_library(protobuf::libprotoc UNKNOWN IMPORTED) + set_target_properties(protobuf::libprotoc PROPERTIES + INTERFACE_INCLUDE_DIRECTORIES "${Protobuf_INCLUDE_DIR}") + if(EXISTS "${Protobuf_PROTOC_LIBRARY}") + set_target_properties(protobuf::libprotoc PROPERTIES + IMPORTED_LOCATION "${Protobuf_PROTOC_LIBRARY}") + endif() + if(EXISTS "${Protobuf_PROTOC_LIBRARY_RELEASE}") + set_property(TARGET protobuf::libprotoc APPEND PROPERTY + IMPORTED_CONFIGURATIONS RELEASE) + set_target_properties(protobuf::libprotoc PROPERTIES + IMPORTED_LOCATION_RELEASE "${Protobuf_PROTOC_LIBRARY_RELEASE}") + endif() + if(EXISTS "${Protobuf_PROTOC_LIBRARY_DEBUG}") + set_property(TARGET protobuf::libprotoc APPEND PROPERTY + IMPORTED_CONFIGURATIONS DEBUG) + set_target_properties(protobuf::libprotoc PROPERTIES + IMPORTED_LOCATION_DEBUG "${Protobuf_PROTOC_LIBRARY_DEBUG}") + endif() + endif() + endif() + + if(Protobuf_PROTOC_EXECUTABLE) + if(NOT TARGET protobuf::protoc) + add_executable(protobuf::protoc IMPORTED) + if(EXISTS "${Protobuf_PROTOC_EXECUTABLE}") + set_target_properties(protobuf::protoc PROPERTIES + IMPORTED_LOCATION "${Protobuf_PROTOC_EXECUTABLE}") + endif() + endif() + endif() +endif() + +include(${CMAKE_CURRENT_LIST_DIR}/FindPackageHandleStandardArgs.cmake) +FIND_PACKAGE_HANDLE_STANDARD_ARGS(Protobuf + REQUIRED_VARS Protobuf_LIBRARIES Protobuf_INCLUDE_DIR + VERSION_VAR Protobuf_VERSION +) + +if(Protobuf_FOUND) + set(Protobuf_INCLUDE_DIRS ${Protobuf_INCLUDE_DIR}) +endif() + +# Restore the original find library ordering +if( Protobuf_USE_STATIC_LIBS ) + set(CMAKE_FIND_LIBRARY_SUFFIXES ${_protobuf_ORIG_CMAKE_FIND_LIBRARY_SUFFIXES}) +endif() + +# Backwards compatibility +# Define upper case versions of output variables +foreach(Camel + Protobuf_SRC_ROOT_FOLDER + Protobuf_IMPORT_DIRS + Protobuf_DEBUG + Protobuf_INCLUDE_DIRS + Protobuf_LIBRARIES + Protobuf_PROTOC_LIBRARIES + Protobuf_LITE_LIBRARIES + Protobuf_LIBRARY + Protobuf_PROTOC_LIBRARY + Protobuf_INCLUDE_DIR + Protobuf_PROTOC_EXECUTABLE + Protobuf_LIBRARY_DEBUG + Protobuf_PROTOC_LIBRARY_DEBUG + Protobuf_LITE_LIBRARY + Protobuf_LITE_LIBRARY_DEBUG + ) + string(TOUPPER ${Camel} UPPER) + set(${UPPER} ${${Camel}}) +endforeach() \ No newline at end of file diff --git a/cmake/SelectLibraryConfigurations.cmake b/cmake/SelectLibraryConfigurations.cmake new file mode 100644 index 000000000..d5e4270ea --- /dev/null +++ b/cmake/SelectLibraryConfigurations.cmake @@ -0,0 +1,71 @@ +# Distributed under the OSI-approved BSD 3-Clause License. See accompanying +# file Copyright.txt or https://cmake.org/licensing for details. + +#.rst: +# SelectLibraryConfigurations +# --------------------------- +# +# +# +# select_library_configurations( basename ) +# +# This macro takes a library base name as an argument, and will choose +# good values for basename_LIBRARY, basename_LIBRARIES, +# basename_LIBRARY_DEBUG, and basename_LIBRARY_RELEASE depending on what +# has been found and set. If only basename_LIBRARY_RELEASE is defined, +# basename_LIBRARY will be set to the release value, and +# basename_LIBRARY_DEBUG will be set to basename_LIBRARY_DEBUG-NOTFOUND. +# If only basename_LIBRARY_DEBUG is defined, then basename_LIBRARY will +# take the debug value, and basename_LIBRARY_RELEASE will be set to +# basename_LIBRARY_RELEASE-NOTFOUND. +# +# If the generator supports configuration types, then basename_LIBRARY +# and basename_LIBRARIES will be set with debug and optimized flags +# specifying the library to be used for the given configuration. If no +# build type has been set or the generator in use does not support +# configuration types, then basename_LIBRARY and basename_LIBRARIES will +# take only the release value, or the debug value if the release one is +# not set. + +# This macro was adapted from the FindQt4 CMake module and is maintained by Will +# Dicharry . + +macro( select_library_configurations basename ) + if(NOT ${basename}_LIBRARY_RELEASE) + set(${basename}_LIBRARY_RELEASE "${basename}_LIBRARY_RELEASE-NOTFOUND" CACHE FILEPATH "Path to a library.") + endif() + if(NOT ${basename}_LIBRARY_DEBUG) + set(${basename}_LIBRARY_DEBUG "${basename}_LIBRARY_DEBUG-NOTFOUND" CACHE FILEPATH "Path to a library.") + endif() + + get_property(_isMultiConfig GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) + if( ${basename}_LIBRARY_DEBUG AND ${basename}_LIBRARY_RELEASE AND + NOT ${basename}_LIBRARY_DEBUG STREQUAL ${basename}_LIBRARY_RELEASE AND + ( _isMultiConfig OR CMAKE_BUILD_TYPE ) ) + # if the generator is multi-config or if CMAKE_BUILD_TYPE is set for + # single-config generators, set optimized and debug libraries + set( ${basename}_LIBRARY "" ) + foreach( _libname IN LISTS ${basename}_LIBRARY_RELEASE ) + list( APPEND ${basename}_LIBRARY optimized "${_libname}" ) + endforeach() + foreach( _libname IN LISTS ${basename}_LIBRARY_DEBUG ) + list( APPEND ${basename}_LIBRARY debug "${_libname}" ) + endforeach() + elseif( ${basename}_LIBRARY_RELEASE ) + set( ${basename}_LIBRARY ${${basename}_LIBRARY_RELEASE} ) + elseif( ${basename}_LIBRARY_DEBUG ) + set( ${basename}_LIBRARY ${${basename}_LIBRARY_DEBUG} ) + else() + set( ${basename}_LIBRARY "${basename}_LIBRARY-NOTFOUND") + endif() + + set( ${basename}_LIBRARIES "${${basename}_LIBRARY}" ) + + if( ${basename}_LIBRARY ) + set( ${basename}_FOUND TRUE ) + endif() + + mark_as_advanced( ${basename}_LIBRARY_RELEASE + ${basename}_LIBRARY_DEBUG + ) +endmacro() \ No newline at end of file diff --git a/common/CMakeLists.txt b/common/CMakeLists.txt index fb6ee6fcd..09f954064 100644 --- a/common/CMakeLists.txt +++ b/common/CMakeLists.txt @@ -1,4 +1,7 @@ CMAKE_MINIMUM_REQUIRED(VERSION 2.8) +SET(PROTOBUF_GENERATE_CPP_APPEND_PATH "../../") + +PROTOBUF_GENERATE_CPP(PROTO_SRCS PROTO_HEADERS message.proto) SET(common_sources base_packet.cpp @@ -39,9 +42,10 @@ SET(common_sources item_instance.cpp json_config.cpp light_source.cpp - md5.cpp + md5.cpp memory_buffer.cpp memory_mapped_file.cpp + message.pb.cc misc.cpp misc_functions.cpp mutex.cpp @@ -97,8 +101,7 @@ SET(common_sources patches/titanium.cpp patches/titanium_limits.cpp patches/uf.cpp - patches/uf_limits.cpp - proto/message.pb.cc + patches/uf_limits.cpp StackWalker/StackWalker.cpp tinyxml/tinystr.cpp tinyxml/tinyxml.cpp @@ -168,6 +171,7 @@ SET(common_headers md5.h memory_buffer.h memory_mapped_file.h + message.pb.h misc.h misc_functions.h mutex.h @@ -255,7 +259,6 @@ SET(common_headers patches/uf_limits.h patches/uf_ops.h patches/uf_structs.h - proto/message.pb.h StackWalker/StackWalker.h tinyxml/tinystr.h tinyxml/tinyxml.h diff --git a/common/message.proto b/common/message.proto new file mode 100644 index 000000000..d23739851 --- /dev/null +++ b/common/message.proto @@ -0,0 +1,883 @@ +syntax = "proto3"; +package eqproto; + +message ChannelMessage { + int32 chan_num = 1; + int32 language = 2; + string from = 3; + string to = 4; + string message = 5; + int32 guilddbid = 6; + string deliverto = 7; + int32 type = 8; + int32 minstatus = 9; + int32 fromadmin = 10; + bool noreply = 11; + bool is_emote = 12; + //0 not queued, 1 queued, 2 queue full, 3 offline + int32 queued = 13; + //You can specify a zone id if you want a message exclusively to one zone + int32 zone_id = 14; +} + +message CommandMessage { + string author = 1; + string command = 2; + repeated string params = 3; + string result = 4; + bytes payload = 5; +} + +//Daily Gain is a special system for tracking players progression in a daily snapshot. +message DailyGain { + int32 account_id = 1; + int32 character_id = 2; + int32 levels_gained = 3; + int32 experience_gained = 4; + int32 money_earned = 5; + string identity = 6; +} + +//Entity is full of entity data. +message Entity { + int32 id = 1; + string name = 2; + int32 type = 3; + int32 hp = 4; + int32 level = 5; + Position position = 6; + int32 race = 7; + int32 class = 8; +} + +message Entities { + repeated Entity entities = 1; +} + +message Position { + float x = 1; + float y = 2; + float z = 3; + float h = 4; +} + +message TextureProfile { + Texture Head = 1; + Texture Chest = 2; + Texture Arms = 3; + Texture Wrist = 4; + Texture Hands = 5; + Texture Legs = 6; + Texture Feet = 7; + Texture Primary = 8; + Texture Secondary = 9; +} + +message Texture { + uint32 material = 1; + uint32 unknown1 = 2; + uint32 EliteModel = 3; + uint32 HerosForgeModel = 4; + uint32 Unknown2 = 5; +} + +message TintProfile { + Tint Head = 1; + Tint Chest = 2; + Tint Arms = 3; + Tint Wrist = 4; + Tint Hands = 5; + Tint Legs = 6; + Tint Feet = 7; + Tint Primary = 8; + Tint Secondary = 9; +} + +message Tint { + uint32 Blue = 1; + uint32 Green = 2; + uint32 Red = 3; + uint32 UseTint = 4; // if there's a tint, this is FF + uint32 Color = 5; +} + +message Event { + OpCode op = 1; + bytes payload = 2; +} + +//OP_Death +message DeathEvent { + uint32 spawn_id = 1; + uint32 killer_id = 2; + uint32 corpse_id = 3; + uint32 bind_zone_id = 4; + uint32 spell_id = 5; + uint32 attack_skill_id = 6; + uint32 damage = 7; + uint32 unknown028 = 8; +} + +//OP_Damage +message DamageEvent { + uint32 target = 1; + uint32 source = 2; + uint32 type = 3; //slashing, etc. 231 (0xE7) for spells + uint32 spellid = 4; + uint32 damage = 5; + float force = 6; + float meleepush_xy = 7; // see above notes in Action_Struct + float meleepush_z = 8; +} + +//OP_Assist OP_Camp +message EntityEvent { + uint32 entity_id = 1; //source of event trigger. + uint32 target_id = 2; //target or other/source/target entity +} + +//OP_ChannelMessage +message ChannelMessageEvent { + string target_name = 1; // Tell recipient + string sender = 2; // The senders name (len might be wrong) + uint32 language = 3; // Language + uint32 chan_num = 4; // Channel + uint32 cm_unknown4 = 5; // ***Placeholder + uint32 skill_in_language = 6; // The players skill in this language? might be wrong + string message = 7; // Variable length message +} + +//OP_WearChange +message WearChangeEvent { + uint32 spawn_id = 1; + uint32 material = 2; + uint32 unknown06 = 3; + uint32 elite_material = 4; // 1 for Drakkin Elite Material + uint32 hero_forge_model = 5; // New to VoA + uint32 unknown18 = 6; // New to RoF + Tint color = 7; + uint32 wear_slot_id = 8; +} + +//OP_DeleteSpawn +message DeleteSpawnEvent { + uint32 spawn_id = 1; // Spawn ID to delete + uint32 decay = 2; // 0 = vanish immediately, 1 = 'Decay' sparklies for corpses. +} + +//OP_MobHealth, OP_HPUpdate +message HPEvent { + uint32 spawn_id = 1; + uint32 cur_hp = 2; + uint32 max_hp = 3; +} + +//OP_ClientUpdate +message PlayerPositionUpdateEvent { + uint32 spawn_id = 1; + int32 delta_heading = 2; // change in heading + int32 x_pos = 3; // x coord + int32 padding0002 = 4; // ***Placeholder + int32 y_pos = 5; // y coord + int32 animation = 6; // animation + int32 padding0006 = 7; // ***Placeholder + int32 z_pos = 8; // z coord + int32 delta_y = 9; // change in y + int32 delta_x = 10; // change in x + int32 heading = 11; // heading + int32 padding0014 = 12; // ***Placeholder + int32 delta_z = 13; // change in z + int32 padding0018 = 14; // ***Placeholder +} + +//OP_Animation +message AnimationEvent { + uint32 spawnid = 1; + uint32 speed = 2; + uint32 action = 3; +} + +//OP_ZoneEntry OP_NewSpawn +message SpawnEvent { + uint32 unknown0000= 1; + uint32 gm = 2; // 0=no, 1=gm + uint32 unknown0003 = 3; + uint32 aaitle = 4; // 0=none, 1=general, 2=archtype, 3=class + uint32 unknown0004 = 5; + uint32 anon = 6; // 0=normal, 1=anon, 2=roleplay + uint32 face = 7; // Face id for players + string name = 8; // Player's Name + uint32 deity = 9; // Player's Deity + uint32 unknown0073 = 10; + float size = 11; // Model size + uint32 unknown0079 = 12; + uint32 NPC = 13; // 0=player,1=npc,2=pc corpse,3=npc corpse,a + uint32 invis = 14; // Invis (0=not, 1=invis) + uint32 haircolor = 15; // Hair color + uint32 curHp = 16; // Current hp %%% wrong + uint32 max_hp = 17; // (name prolly wrong)takes on the value 100 for players, 100 or 110 for NPCs and 120 for PC corpses... + uint32 findable = 18; // 0=can't be found, 1=can be found + uint32 unknown0089 = 19; + int32 deltaHeading = 20; // change in heading + int32 x = 21; // x coord + int32 padding0054 = 22; // ***Placeholder + int32 y = 23; // y coord + int32 animation = 24; // animation + int32 padding0058 = 25; // ***Placeholder + int32 z = 26; // z coord + int32 deltaY = 27; // change in y + int32 deltaX = 28; // change in x + uint32 heading = 29; // heading + int32 padding0066 = 30; // ***Placeholder + int32 deltaZ = 31; // change in z + int32 padding0070 = 32; // ***Placeholder + uint32 eyecolor1 = 33; // Player's left eye color + uint32 unknown0115 = 34; // Was [24] + uint32 StandState = 35; // stand state for SoF+ 0x64 for normal animation + uint32 drakkin_heritage = 36; // Added for SoF + uint32 drakkin_tattoo = 37; // Added for SoF + uint32 drakkin_details = 38; // Added for SoF + uint32 showhelm = 39; // 0=no, 1=yes + uint32 unknown0140 = 40; + uint32 is_npc = 41; // 0=no, 1=yes + uint32 hairstyle = 42; // Hair style + uint32 beard = 43; // Beard style (not totally, sure but maybe!) + uint32 unknown0147 = 44; + uint32 level = 45; // Spawn Level + uint32 PlayerState = 46; // Controls animation stuff // None = 0, Open = 1, WeaponSheathed = 2, Aggressive = 4, ForcedAggressive = 8, InstrumentEquipped = 16, Stunned = 32, PrimaryWeaponEquipped = 64, SecondaryWeaponEquipped = 128 + uint32 beardcolor = 47; // Beard color + string suffix = 48; // Player's suffix (of Veeshan, etc.) + uint32 petOwnerId = 49; // If this is a pet, the spawn id of owner + uint32 guildrank = 50; // 0=normal, 1=officer, 2=leader + uint32 unknown0194 = 51; + TextureProfile equipment = 52; + float runspeed = 53; // Speed when running + uint32 afk = 54; // 0=no, 1=afk + uint32 guildID = 55; // Current guild + string title = 56; // Title + uint32 unknown0274 = 57; // non-zero prefixes name with '!' + uint32 set_to_0xFF = 58; // ***Placeholder (all ff) + uint32 helm = 59; // Helm texture + uint32 race = 60; // Spawn race + uint32 unknown0288 = 61; + string lastName = 62; // Player's Lastname + float walkspeed = 63; // Speed when walking + uint32 unknown0328 = 64; + uint32 is_pet = 65; // 0=no, 1=yes + uint32 light = 66; // Spawn's lightsource %%% wrong + uint32 class_ = 67; // Player's class + uint32 eyecolor2 = 68; // Left eye color + uint32 flymode = 69; + uint32 gender = 70; // Gender (0=male, 1=female) + uint32 bodytype = 71; // Bodytype + uint32 unknown0336 = 72; + //union + uint32 equip_chest2 = 73; // Second place in packet for chest texture (usually 0xFF in live packets) // Not sure why there are 2 of them, but it effects chest texture! + uint32 mount_color = 74; // drogmor: 0=white, 1=black, 2=green, 3=red horse: 0=brown, 1=white, 2=black, 3=tan + //endunion + uint32 spawnId = 75; // Spawn Id + uint32 unknown0344 = 76; + uint32 IsMercenary = 77; + TintProfile equipment_tint = 78; + uint32 lfg = 79; // 0=off, 1=lfg on + bool DestructibleObject = 80; // Only used to flag as a destrible object + string DestructibleModel = 82; // Model of the Destructible Object - Required - Seen "DEST_TNT_G" + string DestructibleName2 = 83; // Secondary name - Not Required - Seen "a_tent" + string DestructibleString = 84; // Unknown - Not Required - Seen "ZoneActor_01186" + uint32 DestructibleAppearance = 85; // Damage Appearance + uint32 DestructibleUnk1 = 86; + uint32 DestructibleID1 = 87; + uint32 DestructibleID2 = 88; + uint32 DestructibleID3 = 89; + uint32 DestructibleID4 = 90; + uint32 DestructibleUnk2 = 91; + uint32 DestructibleUnk3 = 92; + uint32 DestructibleUnk4 = 93; + uint32 DestructibleUnk5 = 94; + uint32 DestructibleUnk6 = 95; + uint32 DestructibleUnk7 = 96; + uint32 DestructibleUnk8 = 97; + uint32 DestructibleUnk9 = 98; + bool targetable_with_hotkey = 99; + bool show_name= 100; +} + +enum OpCode { + //option allow_alias = true; + OP_Unknown = 0; + OP_ExploreUnknown = 1; + OP_0x0193 = 2; + OP_0x0347 = 3; + OP_AAAction = 4; + OP_AAExpUpdate = 5; + OP_AcceptNewTask = 6; + OP_AckPacket = 7; + OP_Action = 8; + OP_Action2 = 9; + OP_AddNimbusEffect = 10; + OP_AdventureData = 11; + OP_AdventureDetails = 12; + OP_AdventureFinish = 13; + OP_AdventureInfo = 14; + OP_AdventureInfoRequest = 15; + OP_AdventureLeaderboardReply = 16; + OP_AdventureLeaderboardRequest = 17; + OP_AdventureMerchantPurchase = 18; + OP_AdventureMerchantRequest = 19; + OP_AdventureMerchantResponse = 20; + OP_AdventureMerchantSell = 21; + OP_AdventurePointsUpdate = 22; + OP_AdventureRequest = 23; + OP_AdventureStatsReply = 24; + OP_AdventureStatsRequest = 25; + OP_AdventureUpdate = 26; + OP_AggroMeterLockTarget = 27; + OP_AggroMeterTargetInfo = 28; + OP_AggroMeterUpdate = 29; + OP_AltCurrency = 30; + OP_AltCurrencyMerchantReply = 31; + OP_AltCurrencyMerchantRequest = 32; + OP_AltCurrencyPurchase = 33; + OP_AltCurrencyReclaim = 34; + OP_AltCurrencySell = 35; + OP_AltCurrencySellSelection = 36; + OP_Animation = 37; //supported + OP_AnnoyingZoneUnknown = 38; + OP_ApplyPoison = 39; + OP_ApproveName = 40; + OP_ApproveWorld = 41; + OP_ApproveZone = 42; + OP_Assist = 43; //supported + OP_AssistGroup = 44; + OP_AugmentInfo = 45; + OP_AugmentItem = 46; + OP_AutoAttack = 47; + OP_AutoAttack2 = 48; + OP_AutoFire = 49; + OP_Bandolier = 50; + OP_BankerChange = 51; + OP_Barter = 52; + OP_Bazaar = 53; + OP_BazaarInspect = 54; + OP_BazaarSearch = 55; + OP_BecomeCorpse = 56; + OP_BecomeTrader = 57; + OP_Begging = 58; + OP_BeginCast = 59; + OP_Bind_Wound = 60; + OP_BlockedBuffs = 61; + OP_BoardBoat = 62; + OP_Buff = 63; + OP_BuffCreate = 64; + OP_BuffRemoveRequest = 65; + OP_Bug = 66; + OP_CameraEffect = 67; + OP_Camp = 68; //supported + OP_CancelSneakHide = 69; + OP_CancelTask = 70; + OP_CancelTrade = 71; + OP_CastSpell = 72; + OP_ChangeSize = 73; + OP_ChannelMessage = 74; + OP_CharacterCreate = 75; + OP_CharacterCreateRequest = 76; + OP_CharInventory = 77; + OP_Charm = 78; + OP_ChatMessage = 79; //used by lua + OP_ClearAA = 80; + OP_ClearBlockedBuffs = 81; + OP_ClearLeadershipAbilities = 82; + OP_ClearNPCMarks = 83; + OP_ClearObject = 84; + OP_ClearSurname = 85; + OP_ClickDoor = 86; + OP_ClickObject = 87; + OP_ClickObjectAction = 88; + OP_ClientError = 89; + OP_ClientReady = 90; + OP_ClientTimeStamp = 91; + OP_ClientUpdate = 92; //supported + OP_CloseContainer = 93; + OP_CloseTributeMaster = 94; + OP_ColoredText = 95; + OP_CombatAbility = 96; + OP_Command = 97; + OP_CompletedTasks = 98; + OP_ConfirmDelete = 99; + OP_Consent = 100; + OP_ConsentDeny = 101; + OP_ConsentResponse = 102; + OP_Consider = 103; + OP_ConsiderCorpse = 104; + OP_Consume = 105; + OP_ControlBoat = 106; + OP_CorpseDrag = 107; + OP_CorpseDrop = 108; + OP_CrashDump = 109; + OP_CrystalCountUpdate = 110; + OP_CrystalCreate = 111; + OP_CrystalReclaim = 112; + OP_CustomTitles = 113; + OP_Damage = 114; + OP_Death = 115; + OP_DelegateAbility = 116; + OP_DeleteCharacter = 117; + OP_DeleteCharge = 118; + OP_DeleteItem = 119; + OP_DeletePetition = 120; + OP_DeleteSpawn = 121; //supported + OP_DeleteSpell = 122; + OP_DenyResponse = 123; + OP_Disarm = 124; + OP_DisarmTraps = 125; + OP_DisciplineTimer = 126; + OP_DisciplineUpdate = 127; + OP_DiscordMerchantInventory = 128; + OP_DoGroupLeadershipAbility = 129; + OP_DuelResponse = 130; + OP_DuelResponse2 = 131; + OP_DumpName = 132; + OP_Dye = 133; + OP_DynamicWall = 134; + OP_DzAddPlayer = 135; + OP_DzChooseZone = 136; + OP_DzCompass = 137; + OP_DzExpeditionEndsWarning = 138; + OP_DzExpeditionInfo = 139; + OP_DzExpeditionList = 140; + OP_DzJoinExpeditionConfirm = 141; + OP_DzJoinExpeditionReply = 142; + OP_DzLeaderStatus = 143; + OP_DzListTimers = 144; + OP_DzMakeLeader = 145; + OP_DzMemberList = 146; + OP_DzMemberStatus = 147; + OP_DzPlayerList = 148; + OP_DzQuit = 149; + OP_DzRemovePlayer = 150; + OP_DzSwapPlayer = 151; + OP_Emote = 152; + OP_EndLootRequest = 153; + OP_EnduranceUpdate = 154; + OP_EnterChat = 155; + OP_EnterWorld = 156; + OP_EnvDamage = 157; + OP_ExpansionInfo = 158; + OP_ExpUpdate = 159; + OP_FaceChange = 160; + OP_Feedback = 161; + OP_FeignDeath = 162; + OP_FellowshipUpdate = 163; + OP_FindPersonReply = 164; + OP_FindPersonRequest = 165; + OP_FinishTrade = 166; + OP_FinishWindow = 167; + OP_FinishWindow2 = 168; + OP_Fishing = 169; + OP_Fling = 170; + OP_FloatListThing = 171; + OP_Forage = 172; + OP_ForceFindPerson = 173; + OP_FormattedMessage = 174; + OP_FriendsWho = 175; + OP_GetGuildMOTD = 176; + OP_GetGuildMOTDReply = 177; + OP_GetGuildsList = 178; + OP_GiveMoney = 179; + OP_GMApproval = 180; + OP_GMBecomeNPC = 181; + OP_GMDelCorpse = 182; + OP_GMEmoteZone = 183; + OP_GMEndTraining = 184; + OP_GMEndTrainingResponse = 185; + OP_GMFind = 186; + OP_GMGoto = 187; + OP_GMHideMe = 188; + OP_GMKick = 189; + OP_GMKill = 190; + OP_GMLastName = 191; + OP_GMNameChange = 192; + OP_GMSearchCorpse = 193; + OP_GMServers = 194; + OP_GMSummon = 195; + OP_GMToggle = 196; + OP_GMTraining = 197; + OP_GMTrainSkill = 198; + OP_GMTrainSkillConfirm = 199; + OP_GMZoneRequest = 200; + OP_GMZoneRequest2 = 201; + OP_GroundSpawn = 202; + OP_GroupAcknowledge = 203; + OP_GroupCancelInvite = 204; + OP_GroupDelete = 205; + OP_GroupDisband = 206; + OP_GroupDisbandOther = 207; + OP_GroupDisbandYou = 208; + OP_GroupFollow = 209; + OP_GroupFollow2 = 210; + OP_GroupInvite = 211; + OP_GroupInvite2 = 212; + OP_GroupLeaderChange = 213; + OP_GroupLeadershipAAUpdate = 214; + OP_GroupMakeLeader = 215; + OP_GroupMentor = 216; + OP_GroupRoles = 217; + OP_GroupUpdate = 218; + OP_GroupUpdateB = 219; + OP_GroupUpdateLeaderAA = 220; + OP_GuildBank = 221; + OP_GuildBankItemList = 222; + OP_GuildCreate = 223; + OP_GuildDelete = 224; + OP_GuildDemote = 225; + OP_GuildInvite = 226; + OP_GuildInviteAccept = 227; + OP_GuildLeader = 228; + OP_GuildManageAdd = 229; + OP_GuildManageBanker = 230; + OP_GuildManageRemove = 231; + OP_GuildManageStatus = 232; + OP_GuildMemberLevelUpdate = 233; + OP_GuildMemberList = 234; + OP_GuildMemberUpdate = 235; + OP_GuildMOTD = 236; + OP_GuildPeace = 237; + OP_GuildPromote = 238; + OP_GuildPublicNote = 239; + OP_GuildRemove = 240; + OP_GuildsList = 241; + OP_GuildStatus = 242; + OP_GuildTributeInfo = 243; + OP_GuildUpdateURLAndChannel = 244; + OP_GuildWar = 245; + OP_Heartbeat = 246; + OP_Hide = 247; + OP_HideCorpse = 248; + OP_HPUpdate = 249; //supported + OP_Illusion = 250; + OP_IncreaseStats = 251; + OP_InitialHPUpdate = 252; + OP_InitialMobHealth = 253; + OP_InspectAnswer = 254; + OP_InspectBuffs = 255; + OP_InspectMessageUpdate = 256; + OP_InspectRequest = 257; + OP_InstillDoubt = 258; + OP_InterruptCast = 259; + OP_ItemLinkClick = 260; + OP_ItemLinkResponse = 261; + OP_ItemLinkText = 262; + OP_ItemName = 263; + OP_ItemPacket = 264; + OP_ItemPreview = 265; + OP_ItemRecastDelay = 266; + OP_ItemVerifyReply = 267; + OP_ItemVerifyRequest = 268; + OP_ItemViewUnknown = 269; + OP_Jump = 270; + OP_KeyRing = 271; + OP_KnowledgeBase = 272; + OP_LDoNButton = 273; + OP_LDoNDisarmTraps = 274; + OP_LDoNInspect = 275; + OP_LDoNOpen = 276; + OP_LDoNPickLock = 277; + OP_LDoNSenseTraps = 278; + OP_LeadershipExpToggle = 279; + OP_LeadershipExpUpdate = 280; + OP_LeaveAdventure = 281; + OP_LeaveBoat = 282; + OP_LevelAppearance = 283; + OP_LevelUpdate = 284; + OP_LFGAppearance = 285; + OP_LFGCommand = 286; + OP_LFGGetMatchesRequest = 287; + OP_LFGGetMatchesResponse = 288; + OP_LFGResponse = 289; + OP_LFGuild = 290; + OP_LFPCommand = 291; + OP_LFPGetMatchesRequest = 292; + OP_LFPGetMatchesResponse = 293; + OP_LinkedReuse = 294; + OP_LoadSpellSet = 295; + OP_LocInfo = 296; + OP_LockoutTimerInfo = 297; + OP_Login = 298; + OP_LoginAccepted = 299; + OP_LoginComplete = 300; + OP_LoginUnknown1 = 301; + OP_LoginUnknown2 = 302; + OP_Logout = 303; + OP_LogoutReply = 304; + OP_LogServer = 305; + OP_LootComplete = 306; + OP_LootItem = 307; + OP_LootRequest = 308; + OP_ManaChange = 309; + OP_ManaUpdate = 310; + OP_MarkNPC = 311; + OP_Marquee = 312; + OP_MemorizeSpell = 313; + OP_Mend = 314; + OP_MendHPUpdate = 315; + OP_MercenaryAssign = 316; + OP_MercenaryCommand = 317; + OP_MercenaryDataRequest = 318; + OP_MercenaryDataResponse = 319; + OP_MercenaryDataUpdate = 320; + OP_MercenaryDataUpdateRequest = 321; + OP_MercenaryDismiss = 322; + OP_MercenaryHire = 323; + OP_MercenarySuspendRequest = 324; + OP_MercenarySuspendResponse = 325; + OP_MercenaryTimer = 326; + OP_MercenaryTimerRequest = 327; + OP_MercenaryUnknown1 = 328; + OP_MercenaryUnsuspendResponse = 329; + OP_MobEnduranceUpdate = 330; + OP_MobHealth = 331; //supported + OP_MobManaUpdate = 332; + OP_MobRename = 333; + OP_MobUpdate = 334; // not used anymore, here for lecacy reasons eqextractor + OP_MoneyOnCorpse = 335; + OP_MoneyUpdate = 336; + OP_MOTD = 337; + OP_MoveCoin = 338; + OP_MoveDoor = 339; + OP_MoveItem = 340; + OP_MoveLogDisregard = 341; + OP_MoveLogRequest = 342; + OP_MultiLineMsg = 343; + OP_NewSpawn = 344; //supported + OP_NewTitlesAvailable = 345; + OP_NewZone = 346; + OP_OnLevelMessage = 347; + OP_OpenContainer = 348; + OP_OpenDiscordMerchant = 349; + OP_OpenGuildTributeMaster = 350; + OP_OpenInventory = 351; + OP_OpenNewTasksWindow = 352; + OP_OpenTributeMaster = 353; + OP_PDeletePetition = 354; + OP_PetBuffWindow = 355; + OP_PetCommands = 356; + OP_PetCommandState = 357; + OP_PetHoTT = 358; + OP_Petition = 359; + OP_PetitionBug = 360; + OP_PetitionCheckIn = 361; + OP_PetitionCheckout = 362; + OP_PetitionCheckout2 = 363; + OP_PetitionDelete = 364; + OP_PetitionQue = 365; + OP_PetitionRefresh = 366; + OP_PetitionResolve = 367; + OP_PetitionSearch = 368; + OP_PetitionSearchResults = 369; + OP_PetitionSearchText = 370; + OP_PetitionUnCheckout = 371; + OP_PetitionUpdate = 372; + OP_PickPocket = 373; + OP_PlayerProfile = 374; + OP_PlayerStateAdd = 375; + OP_PlayerStateRemove = 376; + OP_PlayEverquestRequest = 377; + OP_PlayEverquestResponse = 378; + OP_PlayMP3 = 379; + OP_Poll = 380; + OP_PollResponse = 381; + OP_PopupResponse = 382; + OP_PostEnterWorld = 383; //this is really OP_WorldAccessGrant + OP_PotionBelt = 384; + OP_PreLogoutReply = 385; + OP_PurchaseLeadershipAA = 386; + OP_PVPLeaderBoardDetailsReply = 387; + OP_PVPLeaderBoardDetailsRequest = 388; + OP_PVPLeaderBoardReply = 389; + OP_PVPLeaderBoardRequest = 390; + OP_PVPStats = 391; + OP_QueryResponseThing = 392; + OP_RaidInvite = 393; + OP_RaidJoin = 394; + OP_RaidUpdate = 395; + OP_RandomNameGenerator = 396; + OP_RandomReply = 397; + OP_RandomReq = 398; + OP_ReadBook = 399; + OP_RecipeAutoCombine = 400; + OP_RecipeDetails = 401; + OP_RecipeReply = 402; + OP_RecipesFavorite = 403; + OP_RecipesSearch = 404; + OP_ReclaimCrystals = 405; + OP_ReloadUI = 406; + OP_RemoveAllDoors = 407; + OP_RemoveBlockedBuffs = 408; + OP_RemoveNimbusEffect = 409; + OP_RemoveTrap = 410; + OP_Report = 411; + OP_ReqClientSpawn = 412; + OP_ReqNewZone = 413; + OP_RequestClientZoneChange = 414; + OP_RequestDuel = 415; + OP_RequestKnowledgeBase = 416; + OP_RequestTitles = 417; + OP_RespawnWindow = 418; + OP_RespondAA = 419; + OP_RestState = 420; + OP_Rewind = 421; + OP_RezzAnswer = 422; + OP_RezzComplete = 423; + OP_RezzRequest = 424; + OP_Sacrifice = 425; + OP_SafeFallSuccess = 426; + OP_SafePoint = 427; + OP_Save = 428; + OP_SaveOnZoneReq = 429; + OP_SelectTribute = 430; + OP_SendAAStats = 431; + OP_SendAATable = 432; + OP_SendCharInfo = 433; + OP_SendExpZonein = 434; + OP_SendFindableNPCs = 435; + OP_SendGuildTributes = 436; + OP_SendLoginInfo = 437; + OP_SendMaxCharacters = 438; + OP_SendMembership = 439; + OP_SendMembershipDetails = 440; + OP_SendSystemStats = 441; + OP_SendTitleList = 442; + OP_SendTributes = 443; + OP_SendZonepoints = 444; + OP_SenseHeading = 445; + OP_SenseTraps = 446; + OP_ServerListRequest = 447; + OP_ServerListResponse = 448; + OP_SessionReady = 449; + OP_SetChatServer = 450; + OP_SetChatServer2 = 451; + OP_SetGroupTarget = 452; + OP_SetGuildMOTD = 453; + OP_SetGuildRank = 454; + OP_SetRunMode = 455; + OP_SetServerFilter = 456; + OP_SetStartCity = 457; + OP_SetTitle = 458; + OP_SetTitleReply = 459; + OP_Shielding = 460; + OP_ShopDelItem = 461; + OP_ShopEnd = 462; + OP_ShopEndConfirm = 463; + OP_ShopItem = 464; + OP_ShopPlayerBuy = 465; + OP_ShopPlayerSell = 466; + OP_ShopRequest = 467; + OP_SimpleMessage = 468; + OP_SkillUpdate = 469; + OP_Sneak = 470; + OP_Some3ByteHPUpdate = 471; + OP_Some6ByteHPUpdate = 472; + OP_SomeItemPacketMaybe = 473; + OP_Sound = 474; + OP_SpawnAppearance = 475; + OP_SpawnDoor = 476; + OP_SpawnPositionUpdate = 477; + OP_SpecialMesg = 478; + OP_SpellEffect = 479; + OP_Split = 480; + OP_Stamina = 481; + OP_Stun = 482; + OP_Surname = 483; + OP_SwapSpell = 484; + OP_TargetBuffs = 485; + OP_TargetCommand = 486; + OP_TargetHoTT = 487; + OP_TargetMouse = 488; + OP_TargetReject = 489; + OP_TaskActivity = 490; + OP_TaskActivityComplete = 491; + OP_TaskDescription = 492; + OP_TaskHistoryReply = 493; + OP_TaskHistoryRequest = 494; + OP_TaskMemberList = 495; + OP_Taunt = 496; + OP_TestBuff = 497; + OP_TGB = 498; + OP_TimeOfDay = 499; + OP_Track = 500; + OP_TrackTarget = 501; + OP_TrackUnknown = 502; + OP_TradeAcceptClick = 503; + OP_TradeBusy = 504; + OP_TradeCoins = 505; + OP_TradeMoneyUpdate = 506; + OP_Trader = 507; + OP_TraderBuy = 508; + OP_TraderDelItem = 509; + OP_TradeRequest = 510; + OP_TradeRequestAck = 511; + OP_TraderItemUpdate = 512; + OP_TraderShop = 513; + OP_TradeSkillCombine = 514; + OP_Translocate = 515; + OP_TributeInfo = 516; + OP_TributeItem = 517; + OP_TributeMoney = 518; + OP_TributeNPC = 519; + OP_TributePointUpdate = 520; + OP_TributeTimer = 521; + OP_TributeToggle = 522; + OP_TributeUpdate = 523; + OP_Untargetable = 524; + OP_UpdateAA = 525; + OP_UpdateAura = 526; + OP_UpdateLeadershipAA = 527; + OP_VetClaimReply = 528; + OP_VetClaimRequest = 529; + OP_VetRewardsAvaliable = 530; + OP_VoiceMacroIn = 531; + OP_VoiceMacroOut = 532; + OP_WeaponEquip1 = 533; + OP_WearChange = 534; //supported + OP_Weather = 535; + OP_Weblink = 536; + OP_WhoAllRequest = 537; + OP_WhoAllResponse = 538; + OP_World_Client_CRC1 = 539; + OP_World_Client_CRC2 = 540; + OP_WorldClientReady = 541; + OP_WorldComplete = 542; + OP_WorldLogout = 543; + OP_WorldObjectsSent = 544; + OP_WorldUnknown001 = 545; + OP_XTargetAutoAddHaters = 546; + OP_XTargetOpen = 547; + OP_XTargetOpenResponse = 548; + OP_XTargetRequest = 549; + OP_XTargetResponse = 550; + OP_YellForHelp = 551; + OP_ZoneChange = 552; + OP_ZoneComplete = 553; + OP_ZoneEntry = 554; //supported + OP_ZoneGuildList = 555; + OP_ZoneInUnknown = 556; + OP_ZonePlayerToBind = 557; + OP_ZoneServerInfo = 558; + OP_ZoneServerReady = 559; + OP_ZoneSpawns = 560; + OP_ZoneUnavail = 561; + OP_ResetAA = 562; + OP_Buddy = 563; + OP_ChannelAnnounceJoin = 564; + OP_ChannelAnnounceLeave = 565; + OP_Ignore = 566; + OP_Mail = 567; + OP_MailboxChange = 568; + OP_MailDeliveryStatus = 569; + OP_MailHeader = 570; + OP_MailHeaderCount = 571; + OP_MailLogin = 572; + OP_MailNew = 573; + OP_MailSendBody = 574; + +} \ No newline at end of file diff --git a/common/proto/message.pb.cc b/common/proto/message.pb.cc deleted file mode 100644 index c7d0f6ce4..000000000 --- a/common/proto/message.pb.cc +++ /dev/null @@ -1,15056 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: message.proto - -#include "message.pb.h" - -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -// This is a temporary google only hack -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS -#include "third_party/protobuf/version.h" -#endif -// @@protoc_insertion_point(includes) -namespace eqproto { -class ChannelMessageDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _ChannelMessage_default_instance_; -class CommandMessageDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _CommandMessage_default_instance_; -class DailyGainDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _DailyGain_default_instance_; -class EntityDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Entity_default_instance_; -class EntitiesDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Entities_default_instance_; -class PositionDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Position_default_instance_; -class TextureProfileDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _TextureProfile_default_instance_; -class TextureDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Texture_default_instance_; -class TintProfileDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _TintProfile_default_instance_; -class TintDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Tint_default_instance_; -class EventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _Event_default_instance_; -class DeathEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _DeathEvent_default_instance_; -class DamageEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _DamageEvent_default_instance_; -class EntityEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _EntityEvent_default_instance_; -class ChannelMessageEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _ChannelMessageEvent_default_instance_; -class WearChangeEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _WearChangeEvent_default_instance_; -class DeleteSpawnEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _DeleteSpawnEvent_default_instance_; -class HPEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _HPEvent_default_instance_; -class PlayerPositionUpdateEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _PlayerPositionUpdateEvent_default_instance_; -class AnimationEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _AnimationEvent_default_instance_; -class SpawnEventDefaultTypeInternal { - public: - ::google::protobuf::internal::ExplicitlyConstructed - _instance; -} _SpawnEvent_default_instance_; -} // namespace eqproto -namespace protobuf_message_2eproto { -void InitDefaultsChannelMessageImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_ChannelMessage_default_instance_; - new (ptr) ::eqproto::ChannelMessage(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::ChannelMessage::InitAsDefaultInstance(); -} - -void InitDefaultsChannelMessage() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsChannelMessageImpl); -} - -void InitDefaultsCommandMessageImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_CommandMessage_default_instance_; - new (ptr) ::eqproto::CommandMessage(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::CommandMessage::InitAsDefaultInstance(); -} - -void InitDefaultsCommandMessage() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsCommandMessageImpl); -} - -void InitDefaultsDailyGainImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_DailyGain_default_instance_; - new (ptr) ::eqproto::DailyGain(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::DailyGain::InitAsDefaultInstance(); -} - -void InitDefaultsDailyGain() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDailyGainImpl); -} - -void InitDefaultsEntityImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsPosition(); - { - void* ptr = &::eqproto::_Entity_default_instance_; - new (ptr) ::eqproto::Entity(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Entity::InitAsDefaultInstance(); -} - -void InitDefaultsEntity() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEntityImpl); -} - -void InitDefaultsEntitiesImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsEntity(); - { - void* ptr = &::eqproto::_Entities_default_instance_; - new (ptr) ::eqproto::Entities(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Entities::InitAsDefaultInstance(); -} - -void InitDefaultsEntities() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEntitiesImpl); -} - -void InitDefaultsPositionImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_Position_default_instance_; - new (ptr) ::eqproto::Position(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Position::InitAsDefaultInstance(); -} - -void InitDefaultsPosition() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPositionImpl); -} - -void InitDefaultsTextureProfileImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsTexture(); - { - void* ptr = &::eqproto::_TextureProfile_default_instance_; - new (ptr) ::eqproto::TextureProfile(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::TextureProfile::InitAsDefaultInstance(); -} - -void InitDefaultsTextureProfile() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTextureProfileImpl); -} - -void InitDefaultsTextureImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_Texture_default_instance_; - new (ptr) ::eqproto::Texture(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Texture::InitAsDefaultInstance(); -} - -void InitDefaultsTexture() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTextureImpl); -} - -void InitDefaultsTintProfileImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsTint(); - { - void* ptr = &::eqproto::_TintProfile_default_instance_; - new (ptr) ::eqproto::TintProfile(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::TintProfile::InitAsDefaultInstance(); -} - -void InitDefaultsTintProfile() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTintProfileImpl); -} - -void InitDefaultsTintImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_Tint_default_instance_; - new (ptr) ::eqproto::Tint(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Tint::InitAsDefaultInstance(); -} - -void InitDefaultsTint() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsTintImpl); -} - -void InitDefaultsEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_Event_default_instance_; - new (ptr) ::eqproto::Event(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::Event::InitAsDefaultInstance(); -} - -void InitDefaultsEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEventImpl); -} - -void InitDefaultsDeathEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_DeathEvent_default_instance_; - new (ptr) ::eqproto::DeathEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::DeathEvent::InitAsDefaultInstance(); -} - -void InitDefaultsDeathEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeathEventImpl); -} - -void InitDefaultsDamageEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_DamageEvent_default_instance_; - new (ptr) ::eqproto::DamageEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::DamageEvent::InitAsDefaultInstance(); -} - -void InitDefaultsDamageEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDamageEventImpl); -} - -void InitDefaultsEntityEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_EntityEvent_default_instance_; - new (ptr) ::eqproto::EntityEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::EntityEvent::InitAsDefaultInstance(); -} - -void InitDefaultsEntityEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsEntityEventImpl); -} - -void InitDefaultsChannelMessageEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_ChannelMessageEvent_default_instance_; - new (ptr) ::eqproto::ChannelMessageEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::ChannelMessageEvent::InitAsDefaultInstance(); -} - -void InitDefaultsChannelMessageEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsChannelMessageEventImpl); -} - -void InitDefaultsWearChangeEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsTint(); - { - void* ptr = &::eqproto::_WearChangeEvent_default_instance_; - new (ptr) ::eqproto::WearChangeEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::WearChangeEvent::InitAsDefaultInstance(); -} - -void InitDefaultsWearChangeEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsWearChangeEventImpl); -} - -void InitDefaultsDeleteSpawnEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_DeleteSpawnEvent_default_instance_; - new (ptr) ::eqproto::DeleteSpawnEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::DeleteSpawnEvent::InitAsDefaultInstance(); -} - -void InitDefaultsDeleteSpawnEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsDeleteSpawnEventImpl); -} - -void InitDefaultsHPEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_HPEvent_default_instance_; - new (ptr) ::eqproto::HPEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::HPEvent::InitAsDefaultInstance(); -} - -void InitDefaultsHPEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsHPEventImpl); -} - -void InitDefaultsPlayerPositionUpdateEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_PlayerPositionUpdateEvent_default_instance_; - new (ptr) ::eqproto::PlayerPositionUpdateEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::PlayerPositionUpdateEvent::InitAsDefaultInstance(); -} - -void InitDefaultsPlayerPositionUpdateEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsPlayerPositionUpdateEventImpl); -} - -void InitDefaultsAnimationEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - { - void* ptr = &::eqproto::_AnimationEvent_default_instance_; - new (ptr) ::eqproto::AnimationEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::AnimationEvent::InitAsDefaultInstance(); -} - -void InitDefaultsAnimationEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsAnimationEventImpl); -} - -void InitDefaultsSpawnEventImpl() { - GOOGLE_PROTOBUF_VERIFY_VERSION; - -#ifdef GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - ::google::protobuf::internal::InitProtobufDefaultsForceUnique(); -#else - ::google::protobuf::internal::InitProtobufDefaults(); -#endif // GOOGLE_PROTOBUF_ENFORCE_UNIQUENESS - protobuf_message_2eproto::InitDefaultsTextureProfile(); - protobuf_message_2eproto::InitDefaultsTintProfile(); - { - void* ptr = &::eqproto::_SpawnEvent_default_instance_; - new (ptr) ::eqproto::SpawnEvent(); - ::google::protobuf::internal::OnShutdownDestroyMessage(ptr); - } - ::eqproto::SpawnEvent::InitAsDefaultInstance(); -} - -void InitDefaultsSpawnEvent() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &InitDefaultsSpawnEventImpl); -} - -::google::protobuf::Metadata file_level_metadata[21]; -const ::google::protobuf::EnumDescriptor* file_level_enum_descriptors[1]; - -const ::google::protobuf::uint32 TableStruct::offsets[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, chan_num_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, language_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, from_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, to_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, message_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, guilddbid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, deliverto_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, type_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, minstatus_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, fromadmin_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, noreply_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, is_emote_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, queued_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessage, zone_id_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, author_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, command_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, params_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, result_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::CommandMessage, payload_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, account_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, character_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, levels_gained_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, experience_gained_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, money_earned_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DailyGain, identity_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, name_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, type_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, hp_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, level_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, position_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, race_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entity, class__), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entities, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Entities, entities_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Position, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Position, x_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Position, y_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Position, z_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Position, h_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, head_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, chest_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, arms_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, wrist_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, hands_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, legs_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, feet_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, primary_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TextureProfile, secondary_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, material_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, unknown1_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, elitemodel_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, herosforgemodel_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Texture, unknown2_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, head_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, chest_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, arms_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, wrist_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, hands_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, legs_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, feet_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, primary_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::TintProfile, secondary_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, blue_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, green_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, red_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, usetint_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Tint, color_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Event, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Event, op_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::Event, payload_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, spawn_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, killer_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, corpse_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, bind_zone_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, spell_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, attack_skill_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, damage_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeathEvent, unknown028_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, target_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, source_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, type_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, spellid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, damage_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, force_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, meleepush_xy_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DamageEvent, meleepush_z_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::EntityEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::EntityEvent, entity_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::EntityEvent, target_id_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, target_name_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, sender_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, language_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, chan_num_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, cm_unknown4_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, skill_in_language_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::ChannelMessageEvent, message_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, spawn_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, material_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, unknown06_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, elite_material_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, hero_forge_model_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, unknown18_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, color_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::WearChangeEvent, wear_slot_id_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeleteSpawnEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeleteSpawnEvent, spawn_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::DeleteSpawnEvent, decay_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::HPEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::HPEvent, spawn_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::HPEvent, cur_hp_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::HPEvent, max_hp_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, spawn_id_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, delta_heading_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, x_pos_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, padding0002_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, y_pos_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, animation_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, padding0006_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, z_pos_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, delta_y_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, delta_x_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, heading_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, padding0014_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, delta_z_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::PlayerPositionUpdateEvent, padding0018_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::AnimationEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::AnimationEvent, spawnid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::AnimationEvent, speed_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::AnimationEvent, action_), - ~0u, // no _has_bits_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, _internal_metadata_), - ~0u, // no _extensions_ - ~0u, // no _oneof_case_ - ~0u, // no _weak_field_map_ - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0000_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, gm_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0003_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, aaitle_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0004_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, anon_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, face_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, name_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, deity_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0073_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, size_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0079_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, npc_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, invis_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, haircolor_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, curhp_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, max_hp_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, findable_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0089_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, deltaheading_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, x_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, padding0054_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, y_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, animation_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, padding0058_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, z_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, deltay_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, deltax_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, heading_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, padding0066_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, deltaz_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, padding0070_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, eyecolor1_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0115_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, standstate_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, drakkin_heritage_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, drakkin_tattoo_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, drakkin_details_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, showhelm_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0140_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, is_npc_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, hairstyle_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, beard_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0147_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, level_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, playerstate_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, beardcolor_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, suffix_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, petownerid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, guildrank_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0194_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, equipment_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, runspeed_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, afk_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, guildid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, title_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0274_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, set_to_0xff_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, helm_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, race_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0288_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, lastname_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, walkspeed_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0328_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, is_pet_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, light_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, class__), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, eyecolor2_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, flymode_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, gender_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, bodytype_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0336_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, equip_chest2_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, mount_color_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, spawnid_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, unknown0344_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, ismercenary_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, equipment_tint_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, lfg_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleobject_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructiblemodel_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructiblename2_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructiblestring_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleappearance_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk1_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleid1_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleid2_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleid3_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleid4_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk2_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk3_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk4_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk5_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk6_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk7_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk8_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, destructibleunk9_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, targetable_with_hotkey_), - GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(::eqproto::SpawnEvent, show_name_), -}; -static const ::google::protobuf::internal::MigrationSchema schemas[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { - { 0, -1, sizeof(::eqproto::ChannelMessage)}, - { 19, -1, sizeof(::eqproto::CommandMessage)}, - { 29, -1, sizeof(::eqproto::DailyGain)}, - { 40, -1, sizeof(::eqproto::Entity)}, - { 53, -1, sizeof(::eqproto::Entities)}, - { 59, -1, sizeof(::eqproto::Position)}, - { 68, -1, sizeof(::eqproto::TextureProfile)}, - { 82, -1, sizeof(::eqproto::Texture)}, - { 92, -1, sizeof(::eqproto::TintProfile)}, - { 106, -1, sizeof(::eqproto::Tint)}, - { 116, -1, sizeof(::eqproto::Event)}, - { 123, -1, sizeof(::eqproto::DeathEvent)}, - { 136, -1, sizeof(::eqproto::DamageEvent)}, - { 149, -1, sizeof(::eqproto::EntityEvent)}, - { 156, -1, sizeof(::eqproto::ChannelMessageEvent)}, - { 168, -1, sizeof(::eqproto::WearChangeEvent)}, - { 181, -1, sizeof(::eqproto::DeleteSpawnEvent)}, - { 188, -1, sizeof(::eqproto::HPEvent)}, - { 196, -1, sizeof(::eqproto::PlayerPositionUpdateEvent)}, - { 215, -1, sizeof(::eqproto::AnimationEvent)}, - { 223, -1, sizeof(::eqproto::SpawnEvent)}, -}; - -static ::google::protobuf::Message const * const file_default_instances[] = { - reinterpret_cast(&::eqproto::_ChannelMessage_default_instance_), - reinterpret_cast(&::eqproto::_CommandMessage_default_instance_), - reinterpret_cast(&::eqproto::_DailyGain_default_instance_), - reinterpret_cast(&::eqproto::_Entity_default_instance_), - reinterpret_cast(&::eqproto::_Entities_default_instance_), - reinterpret_cast(&::eqproto::_Position_default_instance_), - reinterpret_cast(&::eqproto::_TextureProfile_default_instance_), - reinterpret_cast(&::eqproto::_Texture_default_instance_), - reinterpret_cast(&::eqproto::_TintProfile_default_instance_), - reinterpret_cast(&::eqproto::_Tint_default_instance_), - reinterpret_cast(&::eqproto::_Event_default_instance_), - reinterpret_cast(&::eqproto::_DeathEvent_default_instance_), - reinterpret_cast(&::eqproto::_DamageEvent_default_instance_), - reinterpret_cast(&::eqproto::_EntityEvent_default_instance_), - reinterpret_cast(&::eqproto::_ChannelMessageEvent_default_instance_), - reinterpret_cast(&::eqproto::_WearChangeEvent_default_instance_), - reinterpret_cast(&::eqproto::_DeleteSpawnEvent_default_instance_), - reinterpret_cast(&::eqproto::_HPEvent_default_instance_), - reinterpret_cast(&::eqproto::_PlayerPositionUpdateEvent_default_instance_), - reinterpret_cast(&::eqproto::_AnimationEvent_default_instance_), - reinterpret_cast(&::eqproto::_SpawnEvent_default_instance_), -}; - -void protobuf_AssignDescriptors() { - AddDescriptors(); - ::google::protobuf::MessageFactory* factory = NULL; - AssignDescriptors( - "message.proto", schemas, file_default_instances, TableStruct::offsets, factory, - file_level_metadata, file_level_enum_descriptors, NULL); -} - -void protobuf_AssignDescriptorsOnce() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &protobuf_AssignDescriptors); -} - -void protobuf_RegisterTypes(const ::std::string&) GOOGLE_PROTOBUF_ATTRIBUTE_COLD; -void protobuf_RegisterTypes(const ::std::string&) { - protobuf_AssignDescriptorsOnce(); - ::google::protobuf::internal::RegisterAllTypes(file_level_metadata, 21); -} - -void AddDescriptorsImpl() { - InitDefaults(); - static const char descriptor[] GOOGLE_PROTOBUF_ATTRIBUTE_SECTION_VARIABLE(protodesc_cold) = { - "\n\rmessage.proto\022\007eqproto\"\375\001\n\016ChannelMess" - "age\022\020\n\010chan_num\030\001 \001(\005\022\020\n\010language\030\002 \001(\005\022" - "\014\n\004from\030\003 \001(\t\022\n\n\002to\030\004 \001(\t\022\017\n\007message\030\005 \001" - "(\t\022\021\n\tguilddbid\030\006 \001(\005\022\021\n\tdeliverto\030\007 \001(\t" - "\022\014\n\004type\030\010 \001(\005\022\021\n\tminstatus\030\t \001(\005\022\021\n\tfro" - "madmin\030\n \001(\005\022\017\n\007noreply\030\013 \001(\010\022\020\n\010is_emot" - "e\030\014 \001(\010\022\016\n\006queued\030\r \001(\005\022\017\n\007zone_id\030\016 \001(\005" - "\"b\n\016CommandMessage\022\016\n\006author\030\001 \001(\t\022\017\n\007co" - "mmand\030\002 \001(\t\022\016\n\006params\030\003 \003(\t\022\016\n\006result\030\004 " - "\001(\t\022\017\n\007payload\030\005 \001(\014\"\217\001\n\tDailyGain\022\022\n\nac" - "count_id\030\001 \001(\005\022\024\n\014character_id\030\002 \001(\005\022\025\n\r" - "levels_gained\030\003 \001(\005\022\031\n\021experience_gained" - "\030\004 \001(\005\022\024\n\014money_earned\030\005 \001(\005\022\020\n\010identity" - "\030\006 \001(\t\"\215\001\n\006Entity\022\n\n\002id\030\001 \001(\005\022\014\n\004name\030\002 " - "\001(\t\022\014\n\004type\030\003 \001(\005\022\n\n\002hp\030\004 \001(\005\022\r\n\005level\030\005" - " \001(\005\022#\n\010position\030\006 \001(\0132\021.eqproto.Positio" - "n\022\014\n\004race\030\007 \001(\005\022\r\n\005class\030\010 \001(\005\"-\n\010Entiti" - "es\022!\n\010entities\030\001 \003(\0132\017.eqproto.Entity\"6\n" - "\010Position\022\t\n\001x\030\001 \001(\002\022\t\n\001y\030\002 \001(\002\022\t\n\001z\030\003 \001" - "(\002\022\t\n\001h\030\004 \001(\002\"\273\002\n\016TextureProfile\022\036\n\004Head" - "\030\001 \001(\0132\020.eqproto.Texture\022\037\n\005Chest\030\002 \001(\0132" - "\020.eqproto.Texture\022\036\n\004Arms\030\003 \001(\0132\020.eqprot" - "o.Texture\022\037\n\005Wrist\030\004 \001(\0132\020.eqproto.Textu" - "re\022\037\n\005Hands\030\005 \001(\0132\020.eqproto.Texture\022\036\n\004L" - "egs\030\006 \001(\0132\020.eqproto.Texture\022\036\n\004Feet\030\007 \001(" - "\0132\020.eqproto.Texture\022!\n\007Primary\030\010 \001(\0132\020.e" - "qproto.Texture\022#\n\tSecondary\030\t \001(\0132\020.eqpr" - "oto.Texture\"l\n\007Texture\022\020\n\010material\030\001 \001(\r" - "\022\020\n\010unknown1\030\002 \001(\r\022\022\n\nEliteModel\030\003 \001(\r\022\027" - "\n\017HerosForgeModel\030\004 \001(\r\022\020\n\010Unknown2\030\005 \001(" - "\r\"\235\002\n\013TintProfile\022\033\n\004Head\030\001 \001(\0132\r.eqprot" - "o.Tint\022\034\n\005Chest\030\002 \001(\0132\r.eqproto.Tint\022\033\n\004" - "Arms\030\003 \001(\0132\r.eqproto.Tint\022\034\n\005Wrist\030\004 \001(\013" - "2\r.eqproto.Tint\022\034\n\005Hands\030\005 \001(\0132\r.eqproto" - ".Tint\022\033\n\004Legs\030\006 \001(\0132\r.eqproto.Tint\022\033\n\004Fe" - "et\030\007 \001(\0132\r.eqproto.Tint\022\036\n\007Primary\030\010 \001(\013" - "2\r.eqproto.Tint\022 \n\tSecondary\030\t \001(\0132\r.eqp" - "roto.Tint\"P\n\004Tint\022\014\n\004Blue\030\001 \001(\r\022\r\n\005Green" - "\030\002 \001(\r\022\013\n\003Red\030\003 \001(\r\022\017\n\007UseTint\030\004 \001(\r\022\r\n\005" - "Color\030\005 \001(\r\"5\n\005Event\022\033\n\002op\030\001 \001(\0162\017.eqpro" - "to.OpCode\022\017\n\007payload\030\002 \001(\014\"\251\001\n\nDeathEven" - "t\022\020\n\010spawn_id\030\001 \001(\r\022\021\n\tkiller_id\030\002 \001(\r\022\021" - "\n\tcorpse_id\030\003 \001(\r\022\024\n\014bind_zone_id\030\004 \001(\r\022" - "\020\n\010spell_id\030\005 \001(\r\022\027\n\017attack_skill_id\030\006 \001" - "(\r\022\016\n\006damage\030\007 \001(\r\022\022\n\nunknown028\030\010 \001(\r\"\226" - "\001\n\013DamageEvent\022\016\n\006target\030\001 \001(\r\022\016\n\006source" - "\030\002 \001(\r\022\014\n\004type\030\003 \001(\r\022\017\n\007spellid\030\004 \001(\r\022\016\n" - "\006damage\030\005 \001(\r\022\r\n\005force\030\006 \001(\002\022\024\n\014meleepus" - "h_xy\030\007 \001(\002\022\023\n\013meleepush_z\030\010 \001(\002\"3\n\013Entit" - "yEvent\022\021\n\tentity_id\030\001 \001(\r\022\021\n\ttarget_id\030\002" - " \001(\r\"\237\001\n\023ChannelMessageEvent\022\023\n\013target_n" - "ame\030\001 \001(\t\022\016\n\006sender\030\002 \001(\t\022\020\n\010language\030\003 " - "\001(\r\022\020\n\010chan_num\030\004 \001(\r\022\023\n\013cm_unknown4\030\005 \001" - "(\r\022\031\n\021skill_in_language\030\006 \001(\r\022\017\n\007message" - "\030\007 \001(\t\"\301\001\n\017WearChangeEvent\022\020\n\010spawn_id\030\001" - " \001(\r\022\020\n\010material\030\002 \001(\r\022\021\n\tunknown06\030\003 \001(" - "\r\022\026\n\016elite_material\030\004 \001(\r\022\030\n\020hero_forge_" - "model\030\005 \001(\r\022\021\n\tunknown18\030\006 \001(\r\022\034\n\005color\030" - "\007 \001(\0132\r.eqproto.Tint\022\024\n\014wear_slot_id\030\010 \001" - "(\r\"3\n\020DeleteSpawnEvent\022\020\n\010spawn_id\030\001 \001(\r" - "\022\r\n\005decay\030\002 \001(\r\";\n\007HPEvent\022\020\n\010spawn_id\030\001" - " \001(\r\022\016\n\006cur_hp\030\002 \001(\r\022\016\n\006max_hp\030\003 \001(\r\"\234\002\n" - "\031PlayerPositionUpdateEvent\022\020\n\010spawn_id\030\001" - " \001(\r\022\025\n\rdelta_heading\030\002 \001(\005\022\r\n\005x_pos\030\003 \001" - "(\005\022\023\n\013padding0002\030\004 \001(\005\022\r\n\005y_pos\030\005 \001(\005\022\021" - "\n\tanimation\030\006 \001(\005\022\023\n\013padding0006\030\007 \001(\005\022\r" - "\n\005z_pos\030\010 \001(\005\022\017\n\007delta_y\030\t \001(\005\022\017\n\007delta_" - "x\030\n \001(\005\022\017\n\007heading\030\013 \001(\005\022\023\n\013padding0014\030" - "\014 \001(\005\022\017\n\007delta_z\030\r \001(\005\022\023\n\013padding0018\030\016 " - "\001(\005\"@\n\016AnimationEvent\022\017\n\007spawnid\030\001 \001(\r\022\r" - "\n\005speed\030\002 \001(\r\022\016\n\006action\030\003 \001(\r\"\337\017\n\nSpawnE" - "vent\022\023\n\013unknown0000\030\001 \001(\r\022\n\n\002gm\030\002 \001(\r\022\023\n" - "\013unknown0003\030\003 \001(\r\022\016\n\006aaitle\030\004 \001(\r\022\023\n\013un" - "known0004\030\005 \001(\r\022\014\n\004anon\030\006 \001(\r\022\014\n\004face\030\007 " - "\001(\r\022\014\n\004name\030\010 \001(\t\022\r\n\005deity\030\t \001(\r\022\023\n\013unkn" - "own0073\030\n \001(\r\022\014\n\004size\030\013 \001(\002\022\023\n\013unknown00" - "79\030\014 \001(\r\022\013\n\003NPC\030\r \001(\r\022\r\n\005invis\030\016 \001(\r\022\021\n\t" - "haircolor\030\017 \001(\r\022\r\n\005curHp\030\020 \001(\r\022\016\n\006max_hp" - "\030\021 \001(\r\022\020\n\010findable\030\022 \001(\r\022\023\n\013unknown0089\030" - "\023 \001(\r\022\024\n\014deltaHeading\030\024 \001(\005\022\t\n\001x\030\025 \001(\005\022\023" - "\n\013padding0054\030\026 \001(\005\022\t\n\001y\030\027 \001(\005\022\021\n\tanimat" - "ion\030\030 \001(\005\022\023\n\013padding0058\030\031 \001(\005\022\t\n\001z\030\032 \001(" - "\005\022\016\n\006deltaY\030\033 \001(\005\022\016\n\006deltaX\030\034 \001(\005\022\017\n\007hea" - "ding\030\035 \001(\r\022\023\n\013padding0066\030\036 \001(\005\022\016\n\006delta" - "Z\030\037 \001(\005\022\023\n\013padding0070\030 \001(\005\022\021\n\teyecolor" - "1\030! \001(\r\022\023\n\013unknown0115\030\" \001(\r\022\022\n\nStandSta" - "te\030# \001(\r\022\030\n\020drakkin_heritage\030$ \001(\r\022\026\n\016dr" - "akkin_tattoo\030% \001(\r\022\027\n\017drakkin_details\030& " - "\001(\r\022\020\n\010showhelm\030\' \001(\r\022\023\n\013unknown0140\030( \001" - "(\r\022\016\n\006is_npc\030) \001(\r\022\021\n\thairstyle\030* \001(\r\022\r\n" - "\005beard\030+ \001(\r\022\023\n\013unknown0147\030, \001(\r\022\r\n\005lev" - "el\030- \001(\r\022\023\n\013PlayerState\030. \001(\r\022\022\n\nbeardco" - "lor\030/ \001(\r\022\016\n\006suffix\0300 \001(\t\022\022\n\npetOwnerId\030" - "1 \001(\r\022\021\n\tguildrank\0302 \001(\r\022\023\n\013unknown0194\030" - "3 \001(\r\022*\n\tequipment\0304 \001(\0132\027.eqproto.Textu" - "reProfile\022\020\n\010runspeed\0305 \001(\002\022\013\n\003afk\0306 \001(\r" - "\022\017\n\007guildID\0307 \001(\r\022\r\n\005title\0308 \001(\t\022\023\n\013unkn" - "own0274\0309 \001(\r\022\023\n\013set_to_0xFF\030: \001(\r\022\014\n\004he" - "lm\030; \001(\r\022\014\n\004race\030< \001(\r\022\023\n\013unknown0288\030= " - "\001(\r\022\020\n\010lastName\030> \001(\t\022\021\n\twalkspeed\030\? \001(\002" - "\022\023\n\013unknown0328\030@ \001(\r\022\016\n\006is_pet\030A \001(\r\022\r\n" - "\005light\030B \001(\r\022\016\n\006class_\030C \001(\r\022\021\n\teyecolor" - "2\030D \001(\r\022\017\n\007flymode\030E \001(\r\022\016\n\006gender\030F \001(\r" - "\022\020\n\010bodytype\030G \001(\r\022\023\n\013unknown0336\030H \001(\r\022" - "\024\n\014equip_chest2\030I \001(\r\022\023\n\013mount_color\030J \001" - "(\r\022\017\n\007spawnId\030K \001(\r\022\023\n\013unknown0344\030L \001(\r" - "\022\023\n\013IsMercenary\030M \001(\r\022,\n\016equipment_tint\030" - "N \001(\0132\024.eqproto.TintProfile\022\013\n\003lfg\030O \001(\r" - "\022\032\n\022DestructibleObject\030P \001(\010\022\031\n\021Destruct" - "ibleModel\030R \001(\t\022\031\n\021DestructibleName2\030S \001" - "(\t\022\032\n\022DestructibleString\030T \001(\t\022\036\n\026Destru" - "ctibleAppearance\030U \001(\r\022\030\n\020DestructibleUn" - "k1\030V \001(\r\022\027\n\017DestructibleID1\030W \001(\r\022\027\n\017Des" - "tructibleID2\030X \001(\r\022\027\n\017DestructibleID3\030Y " - "\001(\r\022\027\n\017DestructibleID4\030Z \001(\r\022\030\n\020Destruct" - "ibleUnk2\030[ \001(\r\022\030\n\020DestructibleUnk3\030\\ \001(\r" - "\022\030\n\020DestructibleUnk4\030] \001(\r\022\030\n\020Destructib" - "leUnk5\030^ \001(\r\022\030\n\020DestructibleUnk6\030_ \001(\r\022\030" - "\n\020DestructibleUnk7\030` \001(\r\022\030\n\020Destructible" - "Unk8\030a \001(\r\022\030\n\020DestructibleUnk9\030b \001(\r\022\036\n\026" - "targetable_with_hotkey\030c \001(\010\022\021\n\tshow_nam" - "e\030d \001(\010*\273e\n\006OpCode\022\016\n\nOP_Unknown\020\000\022\025\n\021OP" - "_ExploreUnknown\020\001\022\r\n\tOP_0x0193\020\002\022\r\n\tOP_0" - "x0347\020\003\022\017\n\013OP_AAAction\020\004\022\022\n\016OP_AAExpUpda" - "te\020\005\022\024\n\020OP_AcceptNewTask\020\006\022\020\n\014OP_AckPack" - "et\020\007\022\r\n\tOP_Action\020\010\022\016\n\nOP_Action2\020\t\022\026\n\022O" - "P_AddNimbusEffect\020\n\022\024\n\020OP_AdventureData\020" - "\013\022\027\n\023OP_AdventureDetails\020\014\022\026\n\022OP_Adventu" - "reFinish\020\r\022\024\n\020OP_AdventureInfo\020\016\022\033\n\027OP_A" - "dventureInfoRequest\020\017\022 \n\034OP_AdventureLea" - "derboardReply\020\020\022\"\n\036OP_AdventureLeaderboa" - "rdRequest\020\021\022 \n\034OP_AdventureMerchantPurch" - "ase\020\022\022\037\n\033OP_AdventureMerchantRequest\020\023\022 " - "\n\034OP_AdventureMerchantResponse\020\024\022\034\n\030OP_A" - "dventureMerchantSell\020\025\022\034\n\030OP_AdventurePo" - "intsUpdate\020\026\022\027\n\023OP_AdventureRequest\020\027\022\032\n" - "\026OP_AdventureStatsReply\020\030\022\034\n\030OP_Adventur" - "eStatsRequest\020\031\022\026\n\022OP_AdventureUpdate\020\032\022" - "\033\n\027OP_AggroMeterLockTarget\020\033\022\033\n\027OP_Aggro" - "MeterTargetInfo\020\034\022\027\n\023OP_AggroMeterUpdate" - "\020\035\022\022\n\016OP_AltCurrency\020\036\022\037\n\033OP_AltCurrency" - "MerchantReply\020\037\022!\n\035OP_AltCurrencyMerchan" - "tRequest\020 \022\032\n\026OP_AltCurrencyPurchase\020!\022\031" - "\n\025OP_AltCurrencyReclaim\020\"\022\026\n\022OP_AltCurre" - "ncySell\020#\022\037\n\033OP_AltCurrencySellSelection" - "\020$\022\020\n\014OP_Animation\020%\022\032\n\026OP_AnnoyingZoneU" - "nknown\020&\022\022\n\016OP_ApplyPoison\020\'\022\022\n\016OP_Appro" - "veName\020(\022\023\n\017OP_ApproveWorld\020)\022\022\n\016OP_Appr" - "oveZone\020*\022\r\n\tOP_Assist\020+\022\022\n\016OP_AssistGro" - "up\020,\022\022\n\016OP_AugmentInfo\020-\022\022\n\016OP_AugmentIt" - "em\020.\022\021\n\rOP_AutoAttack\020/\022\022\n\016OP_AutoAttack" - "2\0200\022\017\n\013OP_AutoFire\0201\022\020\n\014OP_Bandolier\0202\022\023" - "\n\017OP_BankerChange\0203\022\r\n\tOP_Barter\0204\022\r\n\tOP" - "_Bazaar\0205\022\024\n\020OP_BazaarInspect\0206\022\023\n\017OP_Ba" - "zaarSearch\0207\022\023\n\017OP_BecomeCorpse\0208\022\023\n\017OP_" - "BecomeTrader\0209\022\016\n\nOP_Begging\020:\022\020\n\014OP_Beg" - "inCast\020;\022\021\n\rOP_Bind_Wound\020<\022\023\n\017OP_Blocke" - "dBuffs\020=\022\020\n\014OP_BoardBoat\020>\022\013\n\007OP_Buff\020\?\022" - "\021\n\rOP_BuffCreate\020@\022\030\n\024OP_BuffRemoveReque" - "st\020A\022\n\n\006OP_Bug\020B\022\023\n\017OP_CameraEffect\020C\022\013\n" - "\007OP_Camp\020D\022\026\n\022OP_CancelSneakHide\020E\022\021\n\rOP" - "_CancelTask\020F\022\022\n\016OP_CancelTrade\020G\022\020\n\014OP_" - "CastSpell\020H\022\021\n\rOP_ChangeSize\020I\022\025\n\021OP_Cha" - "nnelMessage\020J\022\026\n\022OP_CharacterCreate\020K\022\035\n" - "\031OP_CharacterCreateRequest\020L\022\024\n\020OP_CharI" - "nventory\020M\022\014\n\010OP_Charm\020N\022\022\n\016OP_ChatMessa" - "ge\020O\022\016\n\nOP_ClearAA\020P\022\030\n\024OP_ClearBlockedB" - "uffs\020Q\022\037\n\033OP_ClearLeadershipAbilities\020R\022" - "\024\n\020OP_ClearNPCMarks\020S\022\022\n\016OP_ClearObject\020" - "T\022\023\n\017OP_ClearSurname\020U\022\020\n\014OP_ClickDoor\020V" - "\022\022\n\016OP_ClickObject\020W\022\030\n\024OP_ClickObjectAc" - "tion\020X\022\022\n\016OP_ClientError\020Y\022\022\n\016OP_ClientR" - "eady\020Z\022\026\n\022OP_ClientTimeStamp\020[\022\023\n\017OP_Cli" - "entUpdate\020\\\022\025\n\021OP_CloseContainer\020]\022\031\n\025OP" - "_CloseTributeMaster\020^\022\022\n\016OP_ColoredText\020" - "_\022\024\n\020OP_CombatAbility\020`\022\016\n\nOP_Command\020a\022" - "\025\n\021OP_CompletedTasks\020b\022\024\n\020OP_ConfirmDele" - "te\020c\022\016\n\nOP_Consent\020d\022\022\n\016OP_ConsentDeny\020e" - "\022\026\n\022OP_ConsentResponse\020f\022\017\n\013OP_Consider\020" - "g\022\025\n\021OP_ConsiderCorpse\020h\022\016\n\nOP_Consume\020i" - "\022\022\n\016OP_ControlBoat\020j\022\021\n\rOP_CorpseDrag\020k\022" - "\021\n\rOP_CorpseDrop\020l\022\020\n\014OP_CrashDump\020m\022\031\n\025" - "OP_CrystalCountUpdate\020n\022\024\n\020OP_CrystalCre" - "ate\020o\022\025\n\021OP_CrystalReclaim\020p\022\023\n\017OP_Custo" - "mTitles\020q\022\r\n\tOP_Damage\020r\022\014\n\010OP_Death\020s\022\026" - "\n\022OP_DelegateAbility\020t\022\026\n\022OP_DeleteChara" - "cter\020u\022\023\n\017OP_DeleteCharge\020v\022\021\n\rOP_Delete" - "Item\020w\022\025\n\021OP_DeletePetition\020x\022\022\n\016OP_Dele" - "teSpawn\020y\022\022\n\016OP_DeleteSpell\020z\022\023\n\017OP_Deny" - "Response\020{\022\r\n\tOP_Disarm\020|\022\022\n\016OP_DisarmTr" - "aps\020}\022\026\n\022OP_DisciplineTimer\020~\022\027\n\023OP_Disc" - "iplineUpdate\020\177\022 \n\033OP_DiscordMerchantInve" - "ntory\020\200\001\022 \n\033OP_DoGroupLeadershipAbility\020" - "\201\001\022\024\n\017OP_DuelResponse\020\202\001\022\025\n\020OP_DuelRespo" - "nse2\020\203\001\022\020\n\013OP_DumpName\020\204\001\022\013\n\006OP_Dye\020\205\001\022\023" - "\n\016OP_DynamicWall\020\206\001\022\023\n\016OP_DzAddPlayer\020\207\001" - "\022\024\n\017OP_DzChooseZone\020\210\001\022\021\n\014OP_DzCompass\020\211" - "\001\022\037\n\032OP_DzExpeditionEndsWarning\020\212\001\022\030\n\023OP" - "_DzExpeditionInfo\020\213\001\022\030\n\023OP_DzExpeditionL" - "ist\020\214\001\022\037\n\032OP_DzJoinExpeditionConfirm\020\215\001\022" - "\035\n\030OP_DzJoinExpeditionReply\020\216\001\022\026\n\021OP_DzL" - "eaderStatus\020\217\001\022\024\n\017OP_DzListTimers\020\220\001\022\024\n\017" - "OP_DzMakeLeader\020\221\001\022\024\n\017OP_DzMemberList\020\222\001" - "\022\026\n\021OP_DzMemberStatus\020\223\001\022\024\n\017OP_DzPlayerL" - "ist\020\224\001\022\016\n\tOP_DzQuit\020\225\001\022\026\n\021OP_DzRemovePla" - "yer\020\226\001\022\024\n\017OP_DzSwapPlayer\020\227\001\022\r\n\010OP_Emote" - "\020\230\001\022\026\n\021OP_EndLootRequest\020\231\001\022\027\n\022OP_Endura" - "nceUpdate\020\232\001\022\021\n\014OP_EnterChat\020\233\001\022\022\n\rOP_En" - "terWorld\020\234\001\022\021\n\014OP_EnvDamage\020\235\001\022\025\n\020OP_Exp" - "ansionInfo\020\236\001\022\021\n\014OP_ExpUpdate\020\237\001\022\022\n\rOP_F" - "aceChange\020\240\001\022\020\n\013OP_Feedback\020\241\001\022\022\n\rOP_Fei" - "gnDeath\020\242\001\022\030\n\023OP_FellowshipUpdate\020\243\001\022\027\n\022" - "OP_FindPersonReply\020\244\001\022\031\n\024OP_FindPersonRe" - "quest\020\245\001\022\023\n\016OP_FinishTrade\020\246\001\022\024\n\017OP_Fini" - "shWindow\020\247\001\022\025\n\020OP_FinishWindow2\020\250\001\022\017\n\nOP" - "_Fishing\020\251\001\022\r\n\010OP_Fling\020\252\001\022\026\n\021OP_FloatLi" - "stThing\020\253\001\022\016\n\tOP_Forage\020\254\001\022\027\n\022OP_ForceFi" - "ndPerson\020\255\001\022\030\n\023OP_FormattedMessage\020\256\001\022\022\n" - "\rOP_FriendsWho\020\257\001\022\024\n\017OP_GetGuildMOTD\020\260\001\022" - "\031\n\024OP_GetGuildMOTDReply\020\261\001\022\025\n\020OP_GetGuil" - "dsList\020\262\001\022\021\n\014OP_GiveMoney\020\263\001\022\022\n\rOP_GMApp" - "roval\020\264\001\022\023\n\016OP_GMBecomeNPC\020\265\001\022\023\n\016OP_GMDe" - "lCorpse\020\266\001\022\023\n\016OP_GMEmoteZone\020\267\001\022\025\n\020OP_GM" - "EndTraining\020\270\001\022\035\n\030OP_GMEndTrainingRespon" - "se\020\271\001\022\016\n\tOP_GMFind\020\272\001\022\016\n\tOP_GMGoto\020\273\001\022\020\n" - "\013OP_GMHideMe\020\274\001\022\016\n\tOP_GMKick\020\275\001\022\016\n\tOP_GM" - "Kill\020\276\001\022\022\n\rOP_GMLastName\020\277\001\022\024\n\017OP_GMName" - "Change\020\300\001\022\026\n\021OP_GMSearchCorpse\020\301\001\022\021\n\014OP_" - "GMServers\020\302\001\022\020\n\013OP_GMSummon\020\303\001\022\020\n\013OP_GMT" - "oggle\020\304\001\022\022\n\rOP_GMTraining\020\305\001\022\024\n\017OP_GMTra" - "inSkill\020\306\001\022\033\n\026OP_GMTrainSkillConfirm\020\307\001\022" - "\025\n\020OP_GMZoneRequest\020\310\001\022\026\n\021OP_GMZoneReque" - "st2\020\311\001\022\023\n\016OP_GroundSpawn\020\312\001\022\030\n\023OP_GroupA" - "cknowledge\020\313\001\022\031\n\024OP_GroupCancelInvite\020\314\001" - "\022\023\n\016OP_GroupDelete\020\315\001\022\024\n\017OP_GroupDisband" - "\020\316\001\022\031\n\024OP_GroupDisbandOther\020\317\001\022\027\n\022OP_Gro" - "upDisbandYou\020\320\001\022\023\n\016OP_GroupFollow\020\321\001\022\024\n\017" - "OP_GroupFollow2\020\322\001\022\023\n\016OP_GroupInvite\020\323\001\022" - "\024\n\017OP_GroupInvite2\020\324\001\022\031\n\024OP_GroupLeaderC" - "hange\020\325\001\022\037\n\032OP_GroupLeadershipAAUpdate\020\326" - "\001\022\027\n\022OP_GroupMakeLeader\020\327\001\022\023\n\016OP_GroupMe" - "ntor\020\330\001\022\022\n\rOP_GroupRoles\020\331\001\022\023\n\016OP_GroupU" - "pdate\020\332\001\022\024\n\017OP_GroupUpdateB\020\333\001\022\033\n\026OP_Gro" - "upUpdateLeaderAA\020\334\001\022\021\n\014OP_GuildBank\020\335\001\022\031" - "\n\024OP_GuildBankItemList\020\336\001\022\023\n\016OP_GuildCre" - "ate\020\337\001\022\023\n\016OP_GuildDelete\020\340\001\022\023\n\016OP_GuildD" - "emote\020\341\001\022\023\n\016OP_GuildInvite\020\342\001\022\031\n\024OP_Guil" - "dInviteAccept\020\343\001\022\023\n\016OP_GuildLeader\020\344\001\022\026\n" - "\021OP_GuildManageAdd\020\345\001\022\031\n\024OP_GuildManageB" - "anker\020\346\001\022\031\n\024OP_GuildManageRemove\020\347\001\022\031\n\024O" - "P_GuildManageStatus\020\350\001\022\036\n\031OP_GuildMember" - "LevelUpdate\020\351\001\022\027\n\022OP_GuildMemberList\020\352\001\022" - "\031\n\024OP_GuildMemberUpdate\020\353\001\022\021\n\014OP_GuildMO" - "TD\020\354\001\022\022\n\rOP_GuildPeace\020\355\001\022\024\n\017OP_GuildPro" - "mote\020\356\001\022\027\n\022OP_GuildPublicNote\020\357\001\022\023\n\016OP_G" - "uildRemove\020\360\001\022\022\n\rOP_GuildsList\020\361\001\022\023\n\016OP_" - "GuildStatus\020\362\001\022\030\n\023OP_GuildTributeInfo\020\363\001" - "\022 \n\033OP_GuildUpdateURLAndChannel\020\364\001\022\020\n\013OP" - "_GuildWar\020\365\001\022\021\n\014OP_Heartbeat\020\366\001\022\014\n\007OP_Hi" - "de\020\367\001\022\022\n\rOP_HideCorpse\020\370\001\022\020\n\013OP_HPUpdate" - "\020\371\001\022\020\n\013OP_Illusion\020\372\001\022\025\n\020OP_IncreaseStat" - "s\020\373\001\022\027\n\022OP_InitialHPUpdate\020\374\001\022\030\n\023OP_Init" - "ialMobHealth\020\375\001\022\025\n\020OP_InspectAnswer\020\376\001\022\024" - "\n\017OP_InspectBuffs\020\377\001\022\034\n\027OP_InspectMessag" - "eUpdate\020\200\002\022\026\n\021OP_InspectRequest\020\201\002\022\024\n\017OP" - "_InstillDoubt\020\202\002\022\025\n\020OP_InterruptCast\020\203\002\022" - "\025\n\020OP_ItemLinkClick\020\204\002\022\030\n\023OP_ItemLinkRes" - "ponse\020\205\002\022\024\n\017OP_ItemLinkText\020\206\002\022\020\n\013OP_Ite" - "mName\020\207\002\022\022\n\rOP_ItemPacket\020\210\002\022\023\n\016OP_ItemP" - "review\020\211\002\022\027\n\022OP_ItemRecastDelay\020\212\002\022\027\n\022OP" - "_ItemVerifyReply\020\213\002\022\031\n\024OP_ItemVerifyRequ" - "est\020\214\002\022\027\n\022OP_ItemViewUnknown\020\215\002\022\014\n\007OP_Ju" - "mp\020\216\002\022\017\n\nOP_KeyRing\020\217\002\022\025\n\020OP_KnowledgeBa" - "se\020\220\002\022\022\n\rOP_LDoNButton\020\221\002\022\027\n\022OP_LDoNDisa" - "rmTraps\020\222\002\022\023\n\016OP_LDoNInspect\020\223\002\022\020\n\013OP_LD" - "oNOpen\020\224\002\022\024\n\017OP_LDoNPickLock\020\225\002\022\026\n\021OP_LD" - "oNSenseTraps\020\226\002\022\033\n\026OP_LeadershipExpToggl" - "e\020\227\002\022\033\n\026OP_LeadershipExpUpdate\020\230\002\022\026\n\021OP_" - "LeaveAdventure\020\231\002\022\021\n\014OP_LeaveBoat\020\232\002\022\027\n\022" - "OP_LevelAppearance\020\233\002\022\023\n\016OP_LevelUpdate\020" - "\234\002\022\025\n\020OP_LFGAppearance\020\235\002\022\022\n\rOP_LFGComma" - "nd\020\236\002\022\034\n\027OP_LFGGetMatchesRequest\020\237\002\022\035\n\030O" - "P_LFGGetMatchesResponse\020\240\002\022\023\n\016OP_LFGResp" - "onse\020\241\002\022\017\n\nOP_LFGuild\020\242\002\022\022\n\rOP_LFPComman" - "d\020\243\002\022\034\n\027OP_LFPGetMatchesRequest\020\244\002\022\035\n\030OP" - "_LFPGetMatchesResponse\020\245\002\022\023\n\016OP_LinkedRe" - "use\020\246\002\022\024\n\017OP_LoadSpellSet\020\247\002\022\017\n\nOP_LocIn" - "fo\020\250\002\022\030\n\023OP_LockoutTimerInfo\020\251\002\022\r\n\010OP_Lo" - "gin\020\252\002\022\025\n\020OP_LoginAccepted\020\253\002\022\025\n\020OP_Logi" - "nComplete\020\254\002\022\025\n\020OP_LoginUnknown1\020\255\002\022\025\n\020O" - "P_LoginUnknown2\020\256\002\022\016\n\tOP_Logout\020\257\002\022\023\n\016OP" - "_LogoutReply\020\260\002\022\021\n\014OP_LogServer\020\261\002\022\024\n\017OP" - "_LootComplete\020\262\002\022\020\n\013OP_LootItem\020\263\002\022\023\n\016OP" - "_LootRequest\020\264\002\022\022\n\rOP_ManaChange\020\265\002\022\022\n\rO" - "P_ManaUpdate\020\266\002\022\017\n\nOP_MarkNPC\020\267\002\022\017\n\nOP_M" - "arquee\020\270\002\022\025\n\020OP_MemorizeSpell\020\271\002\022\014\n\007OP_M" - "end\020\272\002\022\024\n\017OP_MendHPUpdate\020\273\002\022\027\n\022OP_Merce" - "naryAssign\020\274\002\022\030\n\023OP_MercenaryCommand\020\275\002\022" - "\034\n\027OP_MercenaryDataRequest\020\276\002\022\035\n\030OP_Merc" - "enaryDataResponse\020\277\002\022\033\n\026OP_MercenaryData" - "Update\020\300\002\022\"\n\035OP_MercenaryDataUpdateReque" - "st\020\301\002\022\030\n\023OP_MercenaryDismiss\020\302\002\022\025\n\020OP_Me" - "rcenaryHire\020\303\002\022\037\n\032OP_MercenarySuspendReq" - "uest\020\304\002\022 \n\033OP_MercenarySuspendResponse\020\305" - "\002\022\026\n\021OP_MercenaryTimer\020\306\002\022\035\n\030OP_Mercenar" - "yTimerRequest\020\307\002\022\031\n\024OP_MercenaryUnknown1" - "\020\310\002\022\"\n\035OP_MercenaryUnsuspendResponse\020\311\002\022" - "\032\n\025OP_MobEnduranceUpdate\020\312\002\022\021\n\014OP_MobHea" - "lth\020\313\002\022\025\n\020OP_MobManaUpdate\020\314\002\022\021\n\014OP_MobR" - "ename\020\315\002\022\021\n\014OP_MobUpdate\020\316\002\022\025\n\020OP_MoneyO" - "nCorpse\020\317\002\022\023\n\016OP_MoneyUpdate\020\320\002\022\014\n\007OP_MO" - "TD\020\321\002\022\020\n\013OP_MoveCoin\020\322\002\022\020\n\013OP_MoveDoor\020\323" - "\002\022\020\n\013OP_MoveItem\020\324\002\022\030\n\023OP_MoveLogDisrega" - "rd\020\325\002\022\026\n\021OP_MoveLogRequest\020\326\002\022\024\n\017OP_Mult" - "iLineMsg\020\327\002\022\020\n\013OP_NewSpawn\020\330\002\022\032\n\025OP_NewT" - "itlesAvailable\020\331\002\022\017\n\nOP_NewZone\020\332\002\022\026\n\021OP" - "_OnLevelMessage\020\333\002\022\025\n\020OP_OpenContainer\020\334" - "\002\022\033\n\026OP_OpenDiscordMerchant\020\335\002\022\036\n\031OP_Ope" - "nGuildTributeMaster\020\336\002\022\025\n\020OP_OpenInvento" - "ry\020\337\002\022\032\n\025OP_OpenNewTasksWindow\020\340\002\022\031\n\024OP_" - "OpenTributeMaster\020\341\002\022\027\n\022OP_PDeletePetiti" - "on\020\342\002\022\025\n\020OP_PetBuffWindow\020\343\002\022\023\n\016OP_PetCo" - "mmands\020\344\002\022\027\n\022OP_PetCommandState\020\345\002\022\017\n\nOP" - "_PetHoTT\020\346\002\022\020\n\013OP_Petition\020\347\002\022\023\n\016OP_Peti" - "tionBug\020\350\002\022\027\n\022OP_PetitionCheckIn\020\351\002\022\030\n\023O" - "P_PetitionCheckout\020\352\002\022\031\n\024OP_PetitionChec" - "kout2\020\353\002\022\026\n\021OP_PetitionDelete\020\354\002\022\023\n\016OP_P" - "etitionQue\020\355\002\022\027\n\022OP_PetitionRefresh\020\356\002\022\027" - "\n\022OP_PetitionResolve\020\357\002\022\026\n\021OP_PetitionSe" - "arch\020\360\002\022\035\n\030OP_PetitionSearchResults\020\361\002\022\032" - "\n\025OP_PetitionSearchText\020\362\002\022\032\n\025OP_Petitio" - "nUnCheckout\020\363\002\022\026\n\021OP_PetitionUpdate\020\364\002\022\022" - "\n\rOP_PickPocket\020\365\002\022\025\n\020OP_PlayerProfile\020\366" - "\002\022\026\n\021OP_PlayerStateAdd\020\367\002\022\031\n\024OP_PlayerSt" - "ateRemove\020\370\002\022\034\n\027OP_PlayEverquestRequest\020" - "\371\002\022\035\n\030OP_PlayEverquestResponse\020\372\002\022\017\n\nOP_" - "PlayMP3\020\373\002\022\014\n\007OP_Poll\020\374\002\022\024\n\017OP_PollRespo" - "nse\020\375\002\022\025\n\020OP_PopupResponse\020\376\002\022\026\n\021OP_Post" - "EnterWorld\020\377\002\022\022\n\rOP_PotionBelt\020\200\003\022\026\n\021OP_" - "PreLogoutReply\020\201\003\022\034\n\027OP_PurchaseLeadersh" - "ipAA\020\202\003\022\"\n\035OP_PVPLeaderBoardDetailsReply" - "\020\203\003\022$\n\037OP_PVPLeaderBoardDetailsRequest\020\204" - "\003\022\033\n\026OP_PVPLeaderBoardReply\020\205\003\022\035\n\030OP_PVP" - "LeaderBoardRequest\020\206\003\022\020\n\013OP_PVPStats\020\207\003\022" - "\032\n\025OP_QueryResponseThing\020\210\003\022\022\n\rOP_RaidIn" - "vite\020\211\003\022\020\n\013OP_RaidJoin\020\212\003\022\022\n\rOP_RaidUpda" - "te\020\213\003\022\033\n\026OP_RandomNameGenerator\020\214\003\022\023\n\016OP" - "_RandomReply\020\215\003\022\021\n\014OP_RandomReq\020\216\003\022\020\n\013OP" - "_ReadBook\020\217\003\022\031\n\024OP_RecipeAutoCombine\020\220\003\022" - "\025\n\020OP_RecipeDetails\020\221\003\022\023\n\016OP_RecipeReply" - "\020\222\003\022\027\n\022OP_RecipesFavorite\020\223\003\022\025\n\020OP_Recip" - "esSearch\020\224\003\022\027\n\022OP_ReclaimCrystals\020\225\003\022\020\n\013" - "OP_ReloadUI\020\226\003\022\026\n\021OP_RemoveAllDoors\020\227\003\022\032" - "\n\025OP_RemoveBlockedBuffs\020\230\003\022\032\n\025OP_RemoveN" - "imbusEffect\020\231\003\022\022\n\rOP_RemoveTrap\020\232\003\022\016\n\tOP" - "_Report\020\233\003\022\026\n\021OP_ReqClientSpawn\020\234\003\022\022\n\rOP" - "_ReqNewZone\020\235\003\022\037\n\032OP_RequestClientZoneCh" - "ange\020\236\003\022\023\n\016OP_RequestDuel\020\237\003\022\034\n\027OP_Reque" - "stKnowledgeBase\020\240\003\022\025\n\020OP_RequestTitles\020\241" - "\003\022\025\n\020OP_RespawnWindow\020\242\003\022\021\n\014OP_RespondAA" - "\020\243\003\022\021\n\014OP_RestState\020\244\003\022\016\n\tOP_Rewind\020\245\003\022\022" - "\n\rOP_RezzAnswer\020\246\003\022\024\n\017OP_RezzComplete\020\247\003" - "\022\023\n\016OP_RezzRequest\020\250\003\022\021\n\014OP_Sacrifice\020\251\003" - "\022\027\n\022OP_SafeFallSuccess\020\252\003\022\021\n\014OP_SafePoin" - "t\020\253\003\022\014\n\007OP_Save\020\254\003\022\025\n\020OP_SaveOnZoneReq\020\255" - "\003\022\025\n\020OP_SelectTribute\020\256\003\022\023\n\016OP_SendAASta" - "ts\020\257\003\022\023\n\016OP_SendAATable\020\260\003\022\024\n\017OP_SendCha" - "rInfo\020\261\003\022\025\n\020OP_SendExpZonein\020\262\003\022\030\n\023OP_Se" - "ndFindableNPCs\020\263\003\022\031\n\024OP_SendGuildTribute" - "s\020\264\003\022\025\n\020OP_SendLoginInfo\020\265\003\022\031\n\024OP_SendMa" - "xCharacters\020\266\003\022\026\n\021OP_SendMembership\020\267\003\022\035" - "\n\030OP_SendMembershipDetails\020\270\003\022\027\n\022OP_Send" - "SystemStats\020\271\003\022\025\n\020OP_SendTitleList\020\272\003\022\024\n" - "\017OP_SendTributes\020\273\003\022\026\n\021OP_SendZonepoints" - "\020\274\003\022\024\n\017OP_SenseHeading\020\275\003\022\022\n\rOP_SenseTra" - "ps\020\276\003\022\031\n\024OP_ServerListRequest\020\277\003\022\032\n\025OP_S" - "erverListResponse\020\300\003\022\024\n\017OP_SessionReady\020" - "\301\003\022\025\n\020OP_SetChatServer\020\302\003\022\026\n\021OP_SetChatS" - "erver2\020\303\003\022\026\n\021OP_SetGroupTarget\020\304\003\022\024\n\017OP_" - "SetGuildMOTD\020\305\003\022\024\n\017OP_SetGuildRank\020\306\003\022\022\n" - "\rOP_SetRunMode\020\307\003\022\027\n\022OP_SetServerFilter\020" - "\310\003\022\024\n\017OP_SetStartCity\020\311\003\022\020\n\013OP_SetTitle\020" - "\312\003\022\025\n\020OP_SetTitleReply\020\313\003\022\021\n\014OP_Shieldin" - "g\020\314\003\022\023\n\016OP_ShopDelItem\020\315\003\022\017\n\nOP_ShopEnd\020" - "\316\003\022\026\n\021OP_ShopEndConfirm\020\317\003\022\020\n\013OP_ShopIte" - "m\020\320\003\022\025\n\020OP_ShopPlayerBuy\020\321\003\022\026\n\021OP_ShopPl" - "ayerSell\020\322\003\022\023\n\016OP_ShopRequest\020\323\003\022\025\n\020OP_S" - "impleMessage\020\324\003\022\023\n\016OP_SkillUpdate\020\325\003\022\r\n\010" - "OP_Sneak\020\326\003\022\031\n\024OP_Some3ByteHPUpdate\020\327\003\022\031" - "\n\024OP_Some6ByteHPUpdate\020\330\003\022\033\n\026OP_SomeItem" - "PacketMaybe\020\331\003\022\r\n\010OP_Sound\020\332\003\022\027\n\022OP_Spaw" - "nAppearance\020\333\003\022\021\n\014OP_SpawnDoor\020\334\003\022\033\n\026OP_" - "SpawnPositionUpdate\020\335\003\022\023\n\016OP_SpecialMesg" - "\020\336\003\022\023\n\016OP_SpellEffect\020\337\003\022\r\n\010OP_Split\020\340\003\022" - "\017\n\nOP_Stamina\020\341\003\022\014\n\007OP_Stun\020\342\003\022\017\n\nOP_Sur" - "name\020\343\003\022\021\n\014OP_SwapSpell\020\344\003\022\023\n\016OP_TargetB" - "uffs\020\345\003\022\025\n\020OP_TargetCommand\020\346\003\022\022\n\rOP_Tar" - "getHoTT\020\347\003\022\023\n\016OP_TargetMouse\020\350\003\022\024\n\017OP_Ta" - "rgetReject\020\351\003\022\024\n\017OP_TaskActivity\020\352\003\022\034\n\027O" - "P_TaskActivityComplete\020\353\003\022\027\n\022OP_TaskDesc" - "ription\020\354\003\022\030\n\023OP_TaskHistoryReply\020\355\003\022\032\n\025" - "OP_TaskHistoryRequest\020\356\003\022\026\n\021OP_TaskMembe" - "rList\020\357\003\022\r\n\010OP_Taunt\020\360\003\022\020\n\013OP_TestBuff\020\361" - "\003\022\013\n\006OP_TGB\020\362\003\022\021\n\014OP_TimeOfDay\020\363\003\022\r\n\010OP_" - "Track\020\364\003\022\023\n\016OP_TrackTarget\020\365\003\022\024\n\017OP_Trac" - "kUnknown\020\366\003\022\030\n\023OP_TradeAcceptClick\020\367\003\022\021\n" - "\014OP_TradeBusy\020\370\003\022\022\n\rOP_TradeCoins\020\371\003\022\030\n\023" - "OP_TradeMoneyUpdate\020\372\003\022\016\n\tOP_Trader\020\373\003\022\021" - "\n\014OP_TraderBuy\020\374\003\022\025\n\020OP_TraderDelItem\020\375\003" - "\022\024\n\017OP_TradeRequest\020\376\003\022\027\n\022OP_TradeReques" - "tAck\020\377\003\022\030\n\023OP_TraderItemUpdate\020\200\004\022\022\n\rOP_" - "TraderShop\020\201\004\022\031\n\024OP_TradeSkillCombine\020\202\004" - "\022\023\n\016OP_Translocate\020\203\004\022\023\n\016OP_TributeInfo\020" - "\204\004\022\023\n\016OP_TributeItem\020\205\004\022\024\n\017OP_TributeMon" - "ey\020\206\004\022\022\n\rOP_TributeNPC\020\207\004\022\032\n\025OP_TributeP" - "ointUpdate\020\210\004\022\024\n\017OP_TributeTimer\020\211\004\022\025\n\020O" - "P_TributeToggle\020\212\004\022\025\n\020OP_TributeUpdate\020\213" - "\004\022\024\n\017OP_Untargetable\020\214\004\022\020\n\013OP_UpdateAA\020\215" - "\004\022\022\n\rOP_UpdateAura\020\216\004\022\032\n\025OP_UpdateLeader" - "shipAA\020\217\004\022\025\n\020OP_VetClaimReply\020\220\004\022\027\n\022OP_V" - "etClaimRequest\020\221\004\022\033\n\026OP_VetRewardsAvalia" - "ble\020\222\004\022\024\n\017OP_VoiceMacroIn\020\223\004\022\025\n\020OP_Voice" - "MacroOut\020\224\004\022\024\n\017OP_WeaponEquip1\020\225\004\022\022\n\rOP_" - "WearChange\020\226\004\022\017\n\nOP_Weather\020\227\004\022\017\n\nOP_Web" - "link\020\230\004\022\025\n\020OP_WhoAllRequest\020\231\004\022\026\n\021OP_Who" - "AllResponse\020\232\004\022\031\n\024OP_World_Client_CRC1\020\233" - "\004\022\031\n\024OP_World_Client_CRC2\020\234\004\022\030\n\023OP_World" - "ClientReady\020\235\004\022\025\n\020OP_WorldComplete\020\236\004\022\023\n" - "\016OP_WorldLogout\020\237\004\022\030\n\023OP_WorldObjectsSen" - "t\020\240\004\022\027\n\022OP_WorldUnknown001\020\241\004\022\034\n\027OP_XTar" - "getAutoAddHaters\020\242\004\022\023\n\016OP_XTargetOpen\020\243\004" - "\022\033\n\026OP_XTargetOpenResponse\020\244\004\022\026\n\021OP_XTar" - "getRequest\020\245\004\022\027\n\022OP_XTargetResponse\020\246\004\022\023" - "\n\016OP_YellForHelp\020\247\004\022\022\n\rOP_ZoneChange\020\250\004\022" - "\024\n\017OP_ZoneComplete\020\251\004\022\021\n\014OP_ZoneEntry\020\252\004" - "\022\025\n\020OP_ZoneGuildList\020\253\004\022\025\n\020OP_ZoneInUnkn" - "own\020\254\004\022\030\n\023OP_ZonePlayerToBind\020\255\004\022\026\n\021OP_Z" - "oneServerInfo\020\256\004\022\027\n\022OP_ZoneServerReady\020\257" - "\004\022\022\n\rOP_ZoneSpawns\020\260\004\022\023\n\016OP_ZoneUnavail\020" - "\261\004\022\017\n\nOP_ResetAA\020\262\004\022\r\n\010OP_Buddy\020\263\004\022\033\n\026OP" - "_ChannelAnnounceJoin\020\264\004\022\034\n\027OP_ChannelAnn" - "ounceLeave\020\265\004\022\016\n\tOP_Ignore\020\266\004\022\014\n\007OP_Mail" - "\020\267\004\022\025\n\020OP_MailboxChange\020\270\004\022\032\n\025OP_MailDel" - "iveryStatus\020\271\004\022\022\n\rOP_MailHeader\020\272\004\022\027\n\022OP" - "_MailHeaderCount\020\273\004\022\021\n\014OP_MailLogin\020\274\004\022\017" - "\n\nOP_MailNew\020\275\004\022\024\n\017OP_MailSendBody\020\276\004b\006p" - "roto3" - }; - ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( - descriptor, 17845); - ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( - "message.proto", &protobuf_RegisterTypes); -} - -void AddDescriptors() { - static GOOGLE_PROTOBUF_DECLARE_ONCE(once); - ::google::protobuf::GoogleOnceInit(&once, &AddDescriptorsImpl); -} -// Force AddDescriptors() to be called at dynamic initialization time. -struct StaticDescriptorInitializer { - StaticDescriptorInitializer() { - AddDescriptors(); - } -} static_descriptor_initializer; -} // namespace protobuf_message_2eproto -namespace eqproto { -const ::google::protobuf::EnumDescriptor* OpCode_descriptor() { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return protobuf_message_2eproto::file_level_enum_descriptors[0]; -} -bool OpCode_IsValid(int value) { - switch (value) { - case 0: - case 1: - case 2: - case 3: - case 4: - case 5: - case 6: - case 7: - case 8: - case 9: - case 10: - case 11: - case 12: - case 13: - case 14: - case 15: - case 16: - case 17: - case 18: - case 19: - case 20: - case 21: - case 22: - case 23: - case 24: - case 25: - case 26: - case 27: - case 28: - case 29: - case 30: - case 31: - case 32: - case 33: - case 34: - case 35: - case 36: - case 37: - case 38: - case 39: - case 40: - case 41: - case 42: - case 43: - case 44: - case 45: - case 46: - case 47: - case 48: - case 49: - case 50: - case 51: - case 52: - case 53: - case 54: - case 55: - case 56: - case 57: - case 58: - case 59: - case 60: - case 61: - case 62: - case 63: - case 64: - case 65: - case 66: - case 67: - case 68: - case 69: - case 70: - case 71: - case 72: - case 73: - case 74: - case 75: - case 76: - case 77: - case 78: - case 79: - case 80: - case 81: - case 82: - case 83: - case 84: - case 85: - case 86: - case 87: - case 88: - case 89: - case 90: - case 91: - case 92: - case 93: - case 94: - case 95: - case 96: - case 97: - case 98: - case 99: - case 100: - case 101: - case 102: - case 103: - case 104: - case 105: - case 106: - case 107: - case 108: - case 109: - case 110: - case 111: - case 112: - case 113: - case 114: - case 115: - case 116: - case 117: - case 118: - case 119: - case 120: - case 121: - case 122: - case 123: - case 124: - case 125: - case 126: - case 127: - case 128: - case 129: - case 130: - case 131: - case 132: - case 133: - case 134: - case 135: - case 136: - case 137: - case 138: - case 139: - case 140: - case 141: - case 142: - case 143: - case 144: - case 145: - case 146: - case 147: - case 148: - case 149: - case 150: - case 151: - case 152: - case 153: - case 154: - case 155: - case 156: - case 157: - case 158: - case 159: - case 160: - case 161: - case 162: - case 163: - case 164: - case 165: - case 166: - case 167: - case 168: - case 169: - case 170: - case 171: - case 172: - case 173: - case 174: - case 175: - case 176: - case 177: - case 178: - case 179: - case 180: - case 181: - case 182: - case 183: - case 184: - case 185: - case 186: - case 187: - case 188: - case 189: - case 190: - case 191: - case 192: - case 193: - case 194: - case 195: - case 196: - case 197: - case 198: - case 199: - case 200: - case 201: - case 202: - case 203: - case 204: - case 205: - case 206: - case 207: - case 208: - case 209: - case 210: - case 211: - case 212: - case 213: - case 214: - case 215: - case 216: - case 217: - case 218: - case 219: - case 220: - case 221: - case 222: - case 223: - case 224: - case 225: - case 226: - case 227: - case 228: - case 229: - case 230: - case 231: - case 232: - case 233: - case 234: - case 235: - case 236: - case 237: - case 238: - case 239: - case 240: - case 241: - case 242: - case 243: - case 244: - case 245: - case 246: - case 247: - case 248: - case 249: - case 250: - case 251: - case 252: - case 253: - case 254: - case 255: - case 256: - case 257: - case 258: - case 259: - case 260: - case 261: - case 262: - case 263: - case 264: - case 265: - case 266: - case 267: - case 268: - case 269: - case 270: - case 271: - case 272: - case 273: - case 274: - case 275: - case 276: - case 277: - case 278: - case 279: - case 280: - case 281: - case 282: - case 283: - case 284: - case 285: - case 286: - case 287: - case 288: - case 289: - case 290: - case 291: - case 292: - case 293: - case 294: - case 295: - case 296: - case 297: - case 298: - case 299: - case 300: - case 301: - case 302: - case 303: - case 304: - case 305: - case 306: - case 307: - case 308: - case 309: - case 310: - case 311: - case 312: - case 313: - case 314: - case 315: - case 316: - case 317: - case 318: - case 319: - case 320: - case 321: - case 322: - case 323: - case 324: - case 325: - case 326: - case 327: - case 328: - case 329: - case 330: - case 331: - case 332: - case 333: - case 334: - case 335: - case 336: - case 337: - case 338: - case 339: - case 340: - case 341: - case 342: - case 343: - case 344: - case 345: - case 346: - case 347: - case 348: - case 349: - case 350: - case 351: - case 352: - case 353: - case 354: - case 355: - case 356: - case 357: - case 358: - case 359: - case 360: - case 361: - case 362: - case 363: - case 364: - case 365: - case 366: - case 367: - case 368: - case 369: - case 370: - case 371: - case 372: - case 373: - case 374: - case 375: - case 376: - case 377: - case 378: - case 379: - case 380: - case 381: - case 382: - case 383: - case 384: - case 385: - case 386: - case 387: - case 388: - case 389: - case 390: - case 391: - case 392: - case 393: - case 394: - case 395: - case 396: - case 397: - case 398: - case 399: - case 400: - case 401: - case 402: - case 403: - case 404: - case 405: - case 406: - case 407: - case 408: - case 409: - case 410: - case 411: - case 412: - case 413: - case 414: - case 415: - case 416: - case 417: - case 418: - case 419: - case 420: - case 421: - case 422: - case 423: - case 424: - case 425: - case 426: - case 427: - case 428: - case 429: - case 430: - case 431: - case 432: - case 433: - case 434: - case 435: - case 436: - case 437: - case 438: - case 439: - case 440: - case 441: - case 442: - case 443: - case 444: - case 445: - case 446: - case 447: - case 448: - case 449: - case 450: - case 451: - case 452: - case 453: - case 454: - case 455: - case 456: - case 457: - case 458: - case 459: - case 460: - case 461: - case 462: - case 463: - case 464: - case 465: - case 466: - case 467: - case 468: - case 469: - case 470: - case 471: - case 472: - case 473: - case 474: - case 475: - case 476: - case 477: - case 478: - case 479: - case 480: - case 481: - case 482: - case 483: - case 484: - case 485: - case 486: - case 487: - case 488: - case 489: - case 490: - case 491: - case 492: - case 493: - case 494: - case 495: - case 496: - case 497: - case 498: - case 499: - case 500: - case 501: - case 502: - case 503: - case 504: - case 505: - case 506: - case 507: - case 508: - case 509: - case 510: - case 511: - case 512: - case 513: - case 514: - case 515: - case 516: - case 517: - case 518: - case 519: - case 520: - case 521: - case 522: - case 523: - case 524: - case 525: - case 526: - case 527: - case 528: - case 529: - case 530: - case 531: - case 532: - case 533: - case 534: - case 535: - case 536: - case 537: - case 538: - case 539: - case 540: - case 541: - case 542: - case 543: - case 544: - case 545: - case 546: - case 547: - case 548: - case 549: - case 550: - case 551: - case 552: - case 553: - case 554: - case 555: - case 556: - case 557: - case 558: - case 559: - case 560: - case 561: - case 562: - case 563: - case 564: - case 565: - case 566: - case 567: - case 568: - case 569: - case 570: - case 571: - case 572: - case 573: - case 574: - return true; - default: - return false; - } -} - - -// =================================================================== - -void ChannelMessage::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int ChannelMessage::kChanNumFieldNumber; -const int ChannelMessage::kLanguageFieldNumber; -const int ChannelMessage::kFromFieldNumber; -const int ChannelMessage::kToFieldNumber; -const int ChannelMessage::kMessageFieldNumber; -const int ChannelMessage::kGuilddbidFieldNumber; -const int ChannelMessage::kDelivertoFieldNumber; -const int ChannelMessage::kTypeFieldNumber; -const int ChannelMessage::kMinstatusFieldNumber; -const int ChannelMessage::kFromadminFieldNumber; -const int ChannelMessage::kNoreplyFieldNumber; -const int ChannelMessage::kIsEmoteFieldNumber; -const int ChannelMessage::kQueuedFieldNumber; -const int ChannelMessage::kZoneIdFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -ChannelMessage::ChannelMessage() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsChannelMessage(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.ChannelMessage) -} -ChannelMessage::ChannelMessage(const ChannelMessage& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.from().size() > 0) { - from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_); - } - to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.to().size() > 0) { - to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_); - } - message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.message().size() > 0) { - message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_); - } - deliverto_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.deliverto().size() > 0) { - deliverto_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.deliverto_); - } - ::memcpy(&chan_num_, &from.chan_num_, - static_cast(reinterpret_cast(&zone_id_) - - reinterpret_cast(&chan_num_)) + sizeof(zone_id_)); - // @@protoc_insertion_point(copy_constructor:eqproto.ChannelMessage) -} - -void ChannelMessage::SharedCtor() { - from_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - to_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - deliverto_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&chan_num_, 0, static_cast( - reinterpret_cast(&zone_id_) - - reinterpret_cast(&chan_num_)) + sizeof(zone_id_)); - _cached_size_ = 0; -} - -ChannelMessage::~ChannelMessage() { - // @@protoc_insertion_point(destructor:eqproto.ChannelMessage) - SharedDtor(); -} - -void ChannelMessage::SharedDtor() { - from_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - to_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - deliverto_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} - -void ChannelMessage::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* ChannelMessage::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const ChannelMessage& ChannelMessage::default_instance() { - ::protobuf_message_2eproto::InitDefaultsChannelMessage(); - return *internal_default_instance(); -} - -ChannelMessage* ChannelMessage::New(::google::protobuf::Arena* arena) const { - ChannelMessage* n = new ChannelMessage; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void ChannelMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.ChannelMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - deliverto_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&chan_num_, 0, static_cast( - reinterpret_cast(&zone_id_) - - reinterpret_cast(&chan_num_)) + sizeof(zone_id_)); - _internal_metadata_.Clear(); -} - -bool ChannelMessage::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.ChannelMessage) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // int32 chan_num = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &chan_num_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 language = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &language_))); - } else { - goto handle_unusual; - } - break; - } - - // string from = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_from())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->from().data(), static_cast(this->from().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessage.from")); - } else { - goto handle_unusual; - } - break; - } - - // string to = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_to())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->to().data(), static_cast(this->to().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessage.to")); - } else { - goto handle_unusual; - } - break; - } - - // string message = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_message())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessage.message")); - } else { - goto handle_unusual; - } - break; - } - - // int32 guilddbid = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &guilddbid_))); - } else { - goto handle_unusual; - } - break; - } - - // string deliverto = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_deliverto())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->deliverto().data(), static_cast(this->deliverto().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessage.deliverto")); - } else { - goto handle_unusual; - } - break; - } - - // int32 type = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &type_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 minstatus = 9; - case 9: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &minstatus_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 fromadmin = 10; - case 10: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &fromadmin_))); - } else { - goto handle_unusual; - } - break; - } - - // bool noreply = 11; - case 11: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( - input, &noreply_))); - } else { - goto handle_unusual; - } - break; - } - - // bool is_emote = 12; - case 12: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( - input, &is_emote_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 queued = 13; - case 13: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &queued_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 zone_id = 14; - case 14: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &zone_id_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.ChannelMessage) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.ChannelMessage) - return false; -#undef DO_ -} - -void ChannelMessage::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.ChannelMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 chan_num = 1; - if (this->chan_num() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->chan_num(), output); - } - - // int32 language = 2; - if (this->language() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->language(), output); - } - - // string from = 3; - if (this->from().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->from().data(), static_cast(this->from().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.from"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 3, this->from(), output); - } - - // string to = 4; - if (this->to().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->to().data(), static_cast(this->to().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.to"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 4, this->to(), output); - } - - // string message = 5; - if (this->message().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.message"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 5, this->message(), output); - } - - // int32 guilddbid = 6; - if (this->guilddbid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->guilddbid(), output); - } - - // string deliverto = 7; - if (this->deliverto().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->deliverto().data(), static_cast(this->deliverto().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.deliverto"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 7, this->deliverto(), output); - } - - // int32 type = 8; - if (this->type() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->type(), output); - } - - // int32 minstatus = 9; - if (this->minstatus() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->minstatus(), output); - } - - // int32 fromadmin = 10; - if (this->fromadmin() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->fromadmin(), output); - } - - // bool noreply = 11; - if (this->noreply() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteBool(11, this->noreply(), output); - } - - // bool is_emote = 12; - if (this->is_emote() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteBool(12, this->is_emote(), output); - } - - // int32 queued = 13; - if (this->queued() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->queued(), output); - } - - // int32 zone_id = 14; - if (this->zone_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->zone_id(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.ChannelMessage) -} - -::google::protobuf::uint8* ChannelMessage::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.ChannelMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 chan_num = 1; - if (this->chan_num() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->chan_num(), target); - } - - // int32 language = 2; - if (this->language() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->language(), target); - } - - // string from = 3; - if (this->from().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->from().data(), static_cast(this->from().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.from"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 3, this->from(), target); - } - - // string to = 4; - if (this->to().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->to().data(), static_cast(this->to().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.to"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 4, this->to(), target); - } - - // string message = 5; - if (this->message().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.message"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 5, this->message(), target); - } - - // int32 guilddbid = 6; - if (this->guilddbid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->guilddbid(), target); - } - - // string deliverto = 7; - if (this->deliverto().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->deliverto().data(), static_cast(this->deliverto().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessage.deliverto"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 7, this->deliverto(), target); - } - - // int32 type = 8; - if (this->type() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->type(), target); - } - - // int32 minstatus = 9; - if (this->minstatus() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->minstatus(), target); - } - - // int32 fromadmin = 10; - if (this->fromadmin() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->fromadmin(), target); - } - - // bool noreply = 11; - if (this->noreply() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(11, this->noreply(), target); - } - - // bool is_emote = 12; - if (this->is_emote() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(12, this->is_emote(), target); - } - - // int32 queued = 13; - if (this->queued() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->queued(), target); - } - - // int32 zone_id = 14; - if (this->zone_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->zone_id(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.ChannelMessage) - return target; -} - -size_t ChannelMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.ChannelMessage) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // string from = 3; - if (this->from().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->from()); - } - - // string to = 4; - if (this->to().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->to()); - } - - // string message = 5; - if (this->message().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->message()); - } - - // string deliverto = 7; - if (this->deliverto().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->deliverto()); - } - - // int32 chan_num = 1; - if (this->chan_num() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->chan_num()); - } - - // int32 language = 2; - if (this->language() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->language()); - } - - // int32 guilddbid = 6; - if (this->guilddbid() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->guilddbid()); - } - - // int32 type = 8; - if (this->type() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->type()); - } - - // int32 minstatus = 9; - if (this->minstatus() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->minstatus()); - } - - // int32 fromadmin = 10; - if (this->fromadmin() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->fromadmin()); - } - - // bool noreply = 11; - if (this->noreply() != 0) { - total_size += 1 + 1; - } - - // bool is_emote = 12; - if (this->is_emote() != 0) { - total_size += 1 + 1; - } - - // int32 queued = 13; - if (this->queued() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->queued()); - } - - // int32 zone_id = 14; - if (this->zone_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->zone_id()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void ChannelMessage::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.ChannelMessage) - GOOGLE_DCHECK_NE(&from, this); - const ChannelMessage* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.ChannelMessage) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.ChannelMessage) - MergeFrom(*source); - } -} - -void ChannelMessage::MergeFrom(const ChannelMessage& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.ChannelMessage) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.from().size() > 0) { - - from_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.from_); - } - if (from.to().size() > 0) { - - to_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.to_); - } - if (from.message().size() > 0) { - - message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_); - } - if (from.deliverto().size() > 0) { - - deliverto_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.deliverto_); - } - if (from.chan_num() != 0) { - set_chan_num(from.chan_num()); - } - if (from.language() != 0) { - set_language(from.language()); - } - if (from.guilddbid() != 0) { - set_guilddbid(from.guilddbid()); - } - if (from.type() != 0) { - set_type(from.type()); - } - if (from.minstatus() != 0) { - set_minstatus(from.minstatus()); - } - if (from.fromadmin() != 0) { - set_fromadmin(from.fromadmin()); - } - if (from.noreply() != 0) { - set_noreply(from.noreply()); - } - if (from.is_emote() != 0) { - set_is_emote(from.is_emote()); - } - if (from.queued() != 0) { - set_queued(from.queued()); - } - if (from.zone_id() != 0) { - set_zone_id(from.zone_id()); - } -} - -void ChannelMessage::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.ChannelMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ChannelMessage::CopyFrom(const ChannelMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.ChannelMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ChannelMessage::IsInitialized() const { - return true; -} - -void ChannelMessage::Swap(ChannelMessage* other) { - if (other == this) return; - InternalSwap(other); -} -void ChannelMessage::InternalSwap(ChannelMessage* other) { - using std::swap; - from_.Swap(&other->from_); - to_.Swap(&other->to_); - message_.Swap(&other->message_); - deliverto_.Swap(&other->deliverto_); - swap(chan_num_, other->chan_num_); - swap(language_, other->language_); - swap(guilddbid_, other->guilddbid_); - swap(type_, other->type_); - swap(minstatus_, other->minstatus_); - swap(fromadmin_, other->fromadmin_); - swap(noreply_, other->noreply_); - swap(is_emote_, other->is_emote_); - swap(queued_, other->queued_); - swap(zone_id_, other->zone_id_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata ChannelMessage::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void CommandMessage::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int CommandMessage::kAuthorFieldNumber; -const int CommandMessage::kCommandFieldNumber; -const int CommandMessage::kParamsFieldNumber; -const int CommandMessage::kResultFieldNumber; -const int CommandMessage::kPayloadFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -CommandMessage::CommandMessage() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsCommandMessage(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.CommandMessage) -} -CommandMessage::CommandMessage(const CommandMessage& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - params_(from.params_), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - author_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.author().size() > 0) { - author_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.author_); - } - command_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.command().size() > 0) { - command_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.command_); - } - result_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.result().size() > 0) { - result_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.result_); - } - payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.payload().size() > 0) { - payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_); - } - // @@protoc_insertion_point(copy_constructor:eqproto.CommandMessage) -} - -void CommandMessage::SharedCtor() { - author_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - command_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - result_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - _cached_size_ = 0; -} - -CommandMessage::~CommandMessage() { - // @@protoc_insertion_point(destructor:eqproto.CommandMessage) - SharedDtor(); -} - -void CommandMessage::SharedDtor() { - author_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - command_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - result_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - payload_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} - -void CommandMessage::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* CommandMessage::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const CommandMessage& CommandMessage::default_instance() { - ::protobuf_message_2eproto::InitDefaultsCommandMessage(); - return *internal_default_instance(); -} - -CommandMessage* CommandMessage::New(::google::protobuf::Arena* arena) const { - CommandMessage* n = new CommandMessage; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void CommandMessage::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.CommandMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - params_.Clear(); - author_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - command_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - result_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - _internal_metadata_.Clear(); -} - -bool CommandMessage::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.CommandMessage) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string author = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_author())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->author().data(), static_cast(this->author().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.CommandMessage.author")); - } else { - goto handle_unusual; - } - break; - } - - // string command = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_command())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->command().data(), static_cast(this->command().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.CommandMessage.command")); - } else { - goto handle_unusual; - } - break; - } - - // repeated string params = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->add_params())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->params(this->params_size() - 1).data(), - static_cast(this->params(this->params_size() - 1).length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.CommandMessage.params")); - } else { - goto handle_unusual; - } - break; - } - - // string result = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_result())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->result().data(), static_cast(this->result().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.CommandMessage.result")); - } else { - goto handle_unusual; - } - break; - } - - // bytes payload = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( - input, this->mutable_payload())); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.CommandMessage) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.CommandMessage) - return false; -#undef DO_ -} - -void CommandMessage::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.CommandMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string author = 1; - if (this->author().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->author().data(), static_cast(this->author().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.author"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->author(), output); - } - - // string command = 2; - if (this->command().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->command().data(), static_cast(this->command().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.command"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->command(), output); - } - - // repeated string params = 3; - for (int i = 0, n = this->params_size(); i < n; i++) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->params(i).data(), static_cast(this->params(i).length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.params"); - ::google::protobuf::internal::WireFormatLite::WriteString( - 3, this->params(i), output); - } - - // string result = 4; - if (this->result().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->result().data(), static_cast(this->result().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.result"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 4, this->result(), output); - } - - // bytes payload = 5; - if (this->payload().size() > 0) { - ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( - 5, this->payload(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.CommandMessage) -} - -::google::protobuf::uint8* CommandMessage::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.CommandMessage) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string author = 1; - if (this->author().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->author().data(), static_cast(this->author().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.author"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 1, this->author(), target); - } - - // string command = 2; - if (this->command().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->command().data(), static_cast(this->command().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.command"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 2, this->command(), target); - } - - // repeated string params = 3; - for (int i = 0, n = this->params_size(); i < n; i++) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->params(i).data(), static_cast(this->params(i).length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.params"); - target = ::google::protobuf::internal::WireFormatLite:: - WriteStringToArray(3, this->params(i), target); - } - - // string result = 4; - if (this->result().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->result().data(), static_cast(this->result().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.CommandMessage.result"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 4, this->result(), target); - } - - // bytes payload = 5; - if (this->payload().size() > 0) { - target = - ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( - 5, this->payload(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.CommandMessage) - return target; -} - -size_t CommandMessage::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.CommandMessage) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // repeated string params = 3; - total_size += 1 * - ::google::protobuf::internal::FromIntSize(this->params_size()); - for (int i = 0, n = this->params_size(); i < n; i++) { - total_size += ::google::protobuf::internal::WireFormatLite::StringSize( - this->params(i)); - } - - // string author = 1; - if (this->author().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->author()); - } - - // string command = 2; - if (this->command().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->command()); - } - - // string result = 4; - if (this->result().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->result()); - } - - // bytes payload = 5; - if (this->payload().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::BytesSize( - this->payload()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void CommandMessage::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.CommandMessage) - GOOGLE_DCHECK_NE(&from, this); - const CommandMessage* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.CommandMessage) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.CommandMessage) - MergeFrom(*source); - } -} - -void CommandMessage::MergeFrom(const CommandMessage& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.CommandMessage) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - params_.MergeFrom(from.params_); - if (from.author().size() > 0) { - - author_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.author_); - } - if (from.command().size() > 0) { - - command_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.command_); - } - if (from.result().size() > 0) { - - result_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.result_); - } - if (from.payload().size() > 0) { - - payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_); - } -} - -void CommandMessage::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.CommandMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void CommandMessage::CopyFrom(const CommandMessage& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.CommandMessage) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool CommandMessage::IsInitialized() const { - return true; -} - -void CommandMessage::Swap(CommandMessage* other) { - if (other == this) return; - InternalSwap(other); -} -void CommandMessage::InternalSwap(CommandMessage* other) { - using std::swap; - params_.InternalSwap(&other->params_); - author_.Swap(&other->author_); - command_.Swap(&other->command_); - result_.Swap(&other->result_); - payload_.Swap(&other->payload_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata CommandMessage::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void DailyGain::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int DailyGain::kAccountIdFieldNumber; -const int DailyGain::kCharacterIdFieldNumber; -const int DailyGain::kLevelsGainedFieldNumber; -const int DailyGain::kExperienceGainedFieldNumber; -const int DailyGain::kMoneyEarnedFieldNumber; -const int DailyGain::kIdentityFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -DailyGain::DailyGain() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsDailyGain(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.DailyGain) -} -DailyGain::DailyGain(const DailyGain& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - identity_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.identity().size() > 0) { - identity_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.identity_); - } - ::memcpy(&account_id_, &from.account_id_, - static_cast(reinterpret_cast(&money_earned_) - - reinterpret_cast(&account_id_)) + sizeof(money_earned_)); - // @@protoc_insertion_point(copy_constructor:eqproto.DailyGain) -} - -void DailyGain::SharedCtor() { - identity_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&account_id_, 0, static_cast( - reinterpret_cast(&money_earned_) - - reinterpret_cast(&account_id_)) + sizeof(money_earned_)); - _cached_size_ = 0; -} - -DailyGain::~DailyGain() { - // @@protoc_insertion_point(destructor:eqproto.DailyGain) - SharedDtor(); -} - -void DailyGain::SharedDtor() { - identity_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} - -void DailyGain::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* DailyGain::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const DailyGain& DailyGain::default_instance() { - ::protobuf_message_2eproto::InitDefaultsDailyGain(); - return *internal_default_instance(); -} - -DailyGain* DailyGain::New(::google::protobuf::Arena* arena) const { - DailyGain* n = new DailyGain; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void DailyGain::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.DailyGain) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - identity_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&account_id_, 0, static_cast( - reinterpret_cast(&money_earned_) - - reinterpret_cast(&account_id_)) + sizeof(money_earned_)); - _internal_metadata_.Clear(); -} - -bool DailyGain::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.DailyGain) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // int32 account_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &account_id_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 character_id = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &character_id_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 levels_gained = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &levels_gained_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 experience_gained = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &experience_gained_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 money_earned = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &money_earned_))); - } else { - goto handle_unusual; - } - break; - } - - // string identity = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_identity())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->identity().data(), static_cast(this->identity().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.DailyGain.identity")); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.DailyGain) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.DailyGain) - return false; -#undef DO_ -} - -void DailyGain::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.DailyGain) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 account_id = 1; - if (this->account_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->account_id(), output); - } - - // int32 character_id = 2; - if (this->character_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->character_id(), output); - } - - // int32 levels_gained = 3; - if (this->levels_gained() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->levels_gained(), output); - } - - // int32 experience_gained = 4; - if (this->experience_gained() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->experience_gained(), output); - } - - // int32 money_earned = 5; - if (this->money_earned() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->money_earned(), output); - } - - // string identity = 6; - if (this->identity().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->identity().data(), static_cast(this->identity().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.DailyGain.identity"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 6, this->identity(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.DailyGain) -} - -::google::protobuf::uint8* DailyGain::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.DailyGain) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 account_id = 1; - if (this->account_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->account_id(), target); - } - - // int32 character_id = 2; - if (this->character_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->character_id(), target); - } - - // int32 levels_gained = 3; - if (this->levels_gained() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->levels_gained(), target); - } - - // int32 experience_gained = 4; - if (this->experience_gained() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->experience_gained(), target); - } - - // int32 money_earned = 5; - if (this->money_earned() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->money_earned(), target); - } - - // string identity = 6; - if (this->identity().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->identity().data(), static_cast(this->identity().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.DailyGain.identity"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 6, this->identity(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.DailyGain) - return target; -} - -size_t DailyGain::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.DailyGain) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // string identity = 6; - if (this->identity().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->identity()); - } - - // int32 account_id = 1; - if (this->account_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->account_id()); - } - - // int32 character_id = 2; - if (this->character_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->character_id()); - } - - // int32 levels_gained = 3; - if (this->levels_gained() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->levels_gained()); - } - - // int32 experience_gained = 4; - if (this->experience_gained() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->experience_gained()); - } - - // int32 money_earned = 5; - if (this->money_earned() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->money_earned()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void DailyGain::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.DailyGain) - GOOGLE_DCHECK_NE(&from, this); - const DailyGain* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.DailyGain) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.DailyGain) - MergeFrom(*source); - } -} - -void DailyGain::MergeFrom(const DailyGain& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.DailyGain) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.identity().size() > 0) { - - identity_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.identity_); - } - if (from.account_id() != 0) { - set_account_id(from.account_id()); - } - if (from.character_id() != 0) { - set_character_id(from.character_id()); - } - if (from.levels_gained() != 0) { - set_levels_gained(from.levels_gained()); - } - if (from.experience_gained() != 0) { - set_experience_gained(from.experience_gained()); - } - if (from.money_earned() != 0) { - set_money_earned(from.money_earned()); - } -} - -void DailyGain::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.DailyGain) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void DailyGain::CopyFrom(const DailyGain& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.DailyGain) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DailyGain::IsInitialized() const { - return true; -} - -void DailyGain::Swap(DailyGain* other) { - if (other == this) return; - InternalSwap(other); -} -void DailyGain::InternalSwap(DailyGain* other) { - using std::swap; - identity_.Swap(&other->identity_); - swap(account_id_, other->account_id_); - swap(character_id_, other->character_id_); - swap(levels_gained_, other->levels_gained_); - swap(experience_gained_, other->experience_gained_); - swap(money_earned_, other->money_earned_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata DailyGain::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Entity::InitAsDefaultInstance() { - ::eqproto::_Entity_default_instance_._instance.get_mutable()->position_ = const_cast< ::eqproto::Position*>( - ::eqproto::Position::internal_default_instance()); -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Entity::kIdFieldNumber; -const int Entity::kNameFieldNumber; -const int Entity::kTypeFieldNumber; -const int Entity::kHpFieldNumber; -const int Entity::kLevelFieldNumber; -const int Entity::kPositionFieldNumber; -const int Entity::kRaceFieldNumber; -const int Entity::kClassFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Entity::Entity() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsEntity(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Entity) -} -Entity::Entity(const Entity& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.name().size() > 0) { - name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); - } - if (from.has_position()) { - position_ = new ::eqproto::Position(*from.position_); - } else { - position_ = NULL; - } - ::memcpy(&id_, &from.id_, - static_cast(reinterpret_cast(&class__) - - reinterpret_cast(&id_)) + sizeof(class__)); - // @@protoc_insertion_point(copy_constructor:eqproto.Entity) -} - -void Entity::SharedCtor() { - name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&position_, 0, static_cast( - reinterpret_cast(&class__) - - reinterpret_cast(&position_)) + sizeof(class__)); - _cached_size_ = 0; -} - -Entity::~Entity() { - // @@protoc_insertion_point(destructor:eqproto.Entity) - SharedDtor(); -} - -void Entity::SharedDtor() { - name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete position_; -} - -void Entity::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Entity::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Entity& Entity::default_instance() { - ::protobuf_message_2eproto::InitDefaultsEntity(); - return *internal_default_instance(); -} - -Entity* Entity::New(::google::protobuf::Arena* arena) const { - Entity* n = new Entity; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Entity::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Entity) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (GetArenaNoVirtual() == NULL && position_ != NULL) { - delete position_; - } - position_ = NULL; - ::memset(&id_, 0, static_cast( - reinterpret_cast(&class__) - - reinterpret_cast(&id_)) + sizeof(class__)); - _internal_metadata_.Clear(); -} - -bool Entity::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Entity) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // int32 id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &id_))); - } else { - goto handle_unusual; - } - break; - } - - // string name = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_name())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.Entity.name")); - } else { - goto handle_unusual; - } - break; - } - - // int32 type = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &type_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 hp = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &hp_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 level = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &level_))); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Position position = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_position())); - } else { - goto handle_unusual; - } - break; - } - - // int32 race = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &race_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 class = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &class__))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Entity) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Entity) - return false; -#undef DO_ -} - -void Entity::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Entity) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 id = 1; - if (this->id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->id(), output); - } - - // string name = 2; - if (this->name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.Entity.name"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->name(), output); - } - - // int32 type = 3; - if (this->type() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->type(), output); - } - - // int32 hp = 4; - if (this->hp() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->hp(), output); - } - - // int32 level = 5; - if (this->level() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->level(), output); - } - - // .eqproto.Position position = 6; - if (this->has_position()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 6, *this->position_, output); - } - - // int32 race = 7; - if (this->race() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->race(), output); - } - - // int32 class = 8; - if (this->class_() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->class_(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Entity) -} - -::google::protobuf::uint8* Entity::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Entity) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // int32 id = 1; - if (this->id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(1, this->id(), target); - } - - // string name = 2; - if (this->name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.Entity.name"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 2, this->name(), target); - } - - // int32 type = 3; - if (this->type() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->type(), target); - } - - // int32 hp = 4; - if (this->hp() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->hp(), target); - } - - // int32 level = 5; - if (this->level() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->level(), target); - } - - // .eqproto.Position position = 6; - if (this->has_position()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 6, *this->position_, deterministic, target); - } - - // int32 race = 7; - if (this->race() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->race(), target); - } - - // int32 class = 8; - if (this->class_() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->class_(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Entity) - return target; -} - -size_t Entity::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Entity) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // string name = 2; - if (this->name().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->name()); - } - - // .eqproto.Position position = 6; - if (this->has_position()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->position_); - } - - // int32 id = 1; - if (this->id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->id()); - } - - // int32 type = 3; - if (this->type() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->type()); - } - - // int32 hp = 4; - if (this->hp() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->hp()); - } - - // int32 level = 5; - if (this->level() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->level()); - } - - // int32 race = 7; - if (this->race() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->race()); - } - - // int32 class = 8; - if (this->class_() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->class_()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Entity::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Entity) - GOOGLE_DCHECK_NE(&from, this); - const Entity* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Entity) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Entity) - MergeFrom(*source); - } -} - -void Entity::MergeFrom(const Entity& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Entity) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.name().size() > 0) { - - name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); - } - if (from.has_position()) { - mutable_position()->::eqproto::Position::MergeFrom(from.position()); - } - if (from.id() != 0) { - set_id(from.id()); - } - if (from.type() != 0) { - set_type(from.type()); - } - if (from.hp() != 0) { - set_hp(from.hp()); - } - if (from.level() != 0) { - set_level(from.level()); - } - if (from.race() != 0) { - set_race(from.race()); - } - if (from.class_() != 0) { - set_class_(from.class_()); - } -} - -void Entity::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Entity) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Entity::CopyFrom(const Entity& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Entity) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Entity::IsInitialized() const { - return true; -} - -void Entity::Swap(Entity* other) { - if (other == this) return; - InternalSwap(other); -} -void Entity::InternalSwap(Entity* other) { - using std::swap; - name_.Swap(&other->name_); - swap(position_, other->position_); - swap(id_, other->id_); - swap(type_, other->type_); - swap(hp_, other->hp_); - swap(level_, other->level_); - swap(race_, other->race_); - swap(class__, other->class__); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Entity::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Entities::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Entities::kEntitiesFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Entities::Entities() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsEntities(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Entities) -} -Entities::Entities(const Entities& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - entities_(from.entities_), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - // @@protoc_insertion_point(copy_constructor:eqproto.Entities) -} - -void Entities::SharedCtor() { - _cached_size_ = 0; -} - -Entities::~Entities() { - // @@protoc_insertion_point(destructor:eqproto.Entities) - SharedDtor(); -} - -void Entities::SharedDtor() { -} - -void Entities::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Entities::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Entities& Entities::default_instance() { - ::protobuf_message_2eproto::InitDefaultsEntities(); - return *internal_default_instance(); -} - -Entities* Entities::New(::google::protobuf::Arena* arena) const { - Entities* n = new Entities; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Entities::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Entities) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - entities_.Clear(); - _internal_metadata_.Clear(); -} - -bool Entities::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Entities) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // repeated .eqproto.Entity entities = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage(input, add_entities())); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Entities) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Entities) - return false; -#undef DO_ -} - -void Entities::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Entities) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .eqproto.Entity entities = 1; - for (unsigned int i = 0, - n = static_cast(this->entities_size()); i < n; i++) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 1, this->entities(static_cast(i)), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Entities) -} - -::google::protobuf::uint8* Entities::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Entities) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // repeated .eqproto.Entity entities = 1; - for (unsigned int i = 0, - n = static_cast(this->entities_size()); i < n; i++) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 1, this->entities(static_cast(i)), deterministic, target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Entities) - return target; -} - -size_t Entities::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Entities) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // repeated .eqproto.Entity entities = 1; - { - unsigned int count = static_cast(this->entities_size()); - total_size += 1UL * count; - for (unsigned int i = 0; i < count; i++) { - total_size += - ::google::protobuf::internal::WireFormatLite::MessageSize( - this->entities(static_cast(i))); - } - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Entities::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Entities) - GOOGLE_DCHECK_NE(&from, this); - const Entities* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Entities) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Entities) - MergeFrom(*source); - } -} - -void Entities::MergeFrom(const Entities& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Entities) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - entities_.MergeFrom(from.entities_); -} - -void Entities::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Entities) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Entities::CopyFrom(const Entities& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Entities) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Entities::IsInitialized() const { - return true; -} - -void Entities::Swap(Entities* other) { - if (other == this) return; - InternalSwap(other); -} -void Entities::InternalSwap(Entities* other) { - using std::swap; - entities_.InternalSwap(&other->entities_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Entities::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Position::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Position::kXFieldNumber; -const int Position::kYFieldNumber; -const int Position::kZFieldNumber; -const int Position::kHFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Position::Position() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsPosition(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Position) -} -Position::Position(const Position& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&x_, &from.x_, - static_cast(reinterpret_cast(&h_) - - reinterpret_cast(&x_)) + sizeof(h_)); - // @@protoc_insertion_point(copy_constructor:eqproto.Position) -} - -void Position::SharedCtor() { - ::memset(&x_, 0, static_cast( - reinterpret_cast(&h_) - - reinterpret_cast(&x_)) + sizeof(h_)); - _cached_size_ = 0; -} - -Position::~Position() { - // @@protoc_insertion_point(destructor:eqproto.Position) - SharedDtor(); -} - -void Position::SharedDtor() { -} - -void Position::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Position::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Position& Position::default_instance() { - ::protobuf_message_2eproto::InitDefaultsPosition(); - return *internal_default_instance(); -} - -Position* Position::New(::google::protobuf::Arena* arena) const { - Position* n = new Position; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Position::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Position) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&x_, 0, static_cast( - reinterpret_cast(&h_) - - reinterpret_cast(&x_)) + sizeof(h_)); - _internal_metadata_.Clear(); -} - -bool Position::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Position) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // float x = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(13u /* 13 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &x_))); - } else { - goto handle_unusual; - } - break; - } - - // float y = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(21u /* 21 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &y_))); - } else { - goto handle_unusual; - } - break; - } - - // float z = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(29u /* 29 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &z_))); - } else { - goto handle_unusual; - } - break; - } - - // float h = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(37u /* 37 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &h_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Position) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Position) - return false; -#undef DO_ -} - -void Position::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Position) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // float x = 1; - if (this->x() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(1, this->x(), output); - } - - // float y = 2; - if (this->y() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(2, this->y(), output); - } - - // float z = 3; - if (this->z() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(3, this->z(), output); - } - - // float h = 4; - if (this->h() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(4, this->h(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Position) -} - -::google::protobuf::uint8* Position::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Position) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // float x = 1; - if (this->x() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(1, this->x(), target); - } - - // float y = 2; - if (this->y() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(2, this->y(), target); - } - - // float z = 3; - if (this->z() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(3, this->z(), target); - } - - // float h = 4; - if (this->h() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(4, this->h(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Position) - return target; -} - -size_t Position::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Position) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // float x = 1; - if (this->x() != 0) { - total_size += 1 + 4; - } - - // float y = 2; - if (this->y() != 0) { - total_size += 1 + 4; - } - - // float z = 3; - if (this->z() != 0) { - total_size += 1 + 4; - } - - // float h = 4; - if (this->h() != 0) { - total_size += 1 + 4; - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Position::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Position) - GOOGLE_DCHECK_NE(&from, this); - const Position* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Position) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Position) - MergeFrom(*source); - } -} - -void Position::MergeFrom(const Position& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Position) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.x() != 0) { - set_x(from.x()); - } - if (from.y() != 0) { - set_y(from.y()); - } - if (from.z() != 0) { - set_z(from.z()); - } - if (from.h() != 0) { - set_h(from.h()); - } -} - -void Position::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Position) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Position::CopyFrom(const Position& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Position) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Position::IsInitialized() const { - return true; -} - -void Position::Swap(Position* other) { - if (other == this) return; - InternalSwap(other); -} -void Position::InternalSwap(Position* other) { - using std::swap; - swap(x_, other->x_); - swap(y_, other->y_); - swap(z_, other->z_); - swap(h_, other->h_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Position::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void TextureProfile::InitAsDefaultInstance() { - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->head_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->chest_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->arms_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->wrist_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->hands_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->legs_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->feet_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->primary_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); - ::eqproto::_TextureProfile_default_instance_._instance.get_mutable()->secondary_ = const_cast< ::eqproto::Texture*>( - ::eqproto::Texture::internal_default_instance()); -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int TextureProfile::kHeadFieldNumber; -const int TextureProfile::kChestFieldNumber; -const int TextureProfile::kArmsFieldNumber; -const int TextureProfile::kWristFieldNumber; -const int TextureProfile::kHandsFieldNumber; -const int TextureProfile::kLegsFieldNumber; -const int TextureProfile::kFeetFieldNumber; -const int TextureProfile::kPrimaryFieldNumber; -const int TextureProfile::kSecondaryFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -TextureProfile::TextureProfile() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsTextureProfile(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.TextureProfile) -} -TextureProfile::TextureProfile(const TextureProfile& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - if (from.has_head()) { - head_ = new ::eqproto::Texture(*from.head_); - } else { - head_ = NULL; - } - if (from.has_chest()) { - chest_ = new ::eqproto::Texture(*from.chest_); - } else { - chest_ = NULL; - } - if (from.has_arms()) { - arms_ = new ::eqproto::Texture(*from.arms_); - } else { - arms_ = NULL; - } - if (from.has_wrist()) { - wrist_ = new ::eqproto::Texture(*from.wrist_); - } else { - wrist_ = NULL; - } - if (from.has_hands()) { - hands_ = new ::eqproto::Texture(*from.hands_); - } else { - hands_ = NULL; - } - if (from.has_legs()) { - legs_ = new ::eqproto::Texture(*from.legs_); - } else { - legs_ = NULL; - } - if (from.has_feet()) { - feet_ = new ::eqproto::Texture(*from.feet_); - } else { - feet_ = NULL; - } - if (from.has_primary()) { - primary_ = new ::eqproto::Texture(*from.primary_); - } else { - primary_ = NULL; - } - if (from.has_secondary()) { - secondary_ = new ::eqproto::Texture(*from.secondary_); - } else { - secondary_ = NULL; - } - // @@protoc_insertion_point(copy_constructor:eqproto.TextureProfile) -} - -void TextureProfile::SharedCtor() { - ::memset(&head_, 0, static_cast( - reinterpret_cast(&secondary_) - - reinterpret_cast(&head_)) + sizeof(secondary_)); - _cached_size_ = 0; -} - -TextureProfile::~TextureProfile() { - // @@protoc_insertion_point(destructor:eqproto.TextureProfile) - SharedDtor(); -} - -void TextureProfile::SharedDtor() { - if (this != internal_default_instance()) delete head_; - if (this != internal_default_instance()) delete chest_; - if (this != internal_default_instance()) delete arms_; - if (this != internal_default_instance()) delete wrist_; - if (this != internal_default_instance()) delete hands_; - if (this != internal_default_instance()) delete legs_; - if (this != internal_default_instance()) delete feet_; - if (this != internal_default_instance()) delete primary_; - if (this != internal_default_instance()) delete secondary_; -} - -void TextureProfile::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* TextureProfile::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const TextureProfile& TextureProfile::default_instance() { - ::protobuf_message_2eproto::InitDefaultsTextureProfile(); - return *internal_default_instance(); -} - -TextureProfile* TextureProfile::New(::google::protobuf::Arena* arena) const { - TextureProfile* n = new TextureProfile; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void TextureProfile::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.TextureProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaNoVirtual() == NULL && head_ != NULL) { - delete head_; - } - head_ = NULL; - if (GetArenaNoVirtual() == NULL && chest_ != NULL) { - delete chest_; - } - chest_ = NULL; - if (GetArenaNoVirtual() == NULL && arms_ != NULL) { - delete arms_; - } - arms_ = NULL; - if (GetArenaNoVirtual() == NULL && wrist_ != NULL) { - delete wrist_; - } - wrist_ = NULL; - if (GetArenaNoVirtual() == NULL && hands_ != NULL) { - delete hands_; - } - hands_ = NULL; - if (GetArenaNoVirtual() == NULL && legs_ != NULL) { - delete legs_; - } - legs_ = NULL; - if (GetArenaNoVirtual() == NULL && feet_ != NULL) { - delete feet_; - } - feet_ = NULL; - if (GetArenaNoVirtual() == NULL && primary_ != NULL) { - delete primary_; - } - primary_ = NULL; - if (GetArenaNoVirtual() == NULL && secondary_ != NULL) { - delete secondary_; - } - secondary_ = NULL; - _internal_metadata_.Clear(); -} - -bool TextureProfile::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.TextureProfile) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // .eqproto.Texture Head = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_head())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Chest = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_chest())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Arms = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_arms())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Wrist = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_wrist())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Hands = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_hands())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Legs = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_legs())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Feet = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_feet())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Primary = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_primary())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Texture Secondary = 9; - case 9: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_secondary())); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.TextureProfile) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.TextureProfile) - return false; -#undef DO_ -} - -void TextureProfile::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.TextureProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.Texture Head = 1; - if (this->has_head()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 1, *this->head_, output); - } - - // .eqproto.Texture Chest = 2; - if (this->has_chest()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 2, *this->chest_, output); - } - - // .eqproto.Texture Arms = 3; - if (this->has_arms()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 3, *this->arms_, output); - } - - // .eqproto.Texture Wrist = 4; - if (this->has_wrist()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 4, *this->wrist_, output); - } - - // .eqproto.Texture Hands = 5; - if (this->has_hands()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 5, *this->hands_, output); - } - - // .eqproto.Texture Legs = 6; - if (this->has_legs()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 6, *this->legs_, output); - } - - // .eqproto.Texture Feet = 7; - if (this->has_feet()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 7, *this->feet_, output); - } - - // .eqproto.Texture Primary = 8; - if (this->has_primary()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 8, *this->primary_, output); - } - - // .eqproto.Texture Secondary = 9; - if (this->has_secondary()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 9, *this->secondary_, output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.TextureProfile) -} - -::google::protobuf::uint8* TextureProfile::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.TextureProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.Texture Head = 1; - if (this->has_head()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 1, *this->head_, deterministic, target); - } - - // .eqproto.Texture Chest = 2; - if (this->has_chest()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 2, *this->chest_, deterministic, target); - } - - // .eqproto.Texture Arms = 3; - if (this->has_arms()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 3, *this->arms_, deterministic, target); - } - - // .eqproto.Texture Wrist = 4; - if (this->has_wrist()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 4, *this->wrist_, deterministic, target); - } - - // .eqproto.Texture Hands = 5; - if (this->has_hands()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 5, *this->hands_, deterministic, target); - } - - // .eqproto.Texture Legs = 6; - if (this->has_legs()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 6, *this->legs_, deterministic, target); - } - - // .eqproto.Texture Feet = 7; - if (this->has_feet()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 7, *this->feet_, deterministic, target); - } - - // .eqproto.Texture Primary = 8; - if (this->has_primary()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 8, *this->primary_, deterministic, target); - } - - // .eqproto.Texture Secondary = 9; - if (this->has_secondary()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 9, *this->secondary_, deterministic, target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.TextureProfile) - return target; -} - -size_t TextureProfile::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.TextureProfile) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // .eqproto.Texture Head = 1; - if (this->has_head()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->head_); - } - - // .eqproto.Texture Chest = 2; - if (this->has_chest()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->chest_); - } - - // .eqproto.Texture Arms = 3; - if (this->has_arms()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->arms_); - } - - // .eqproto.Texture Wrist = 4; - if (this->has_wrist()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->wrist_); - } - - // .eqproto.Texture Hands = 5; - if (this->has_hands()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->hands_); - } - - // .eqproto.Texture Legs = 6; - if (this->has_legs()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->legs_); - } - - // .eqproto.Texture Feet = 7; - if (this->has_feet()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->feet_); - } - - // .eqproto.Texture Primary = 8; - if (this->has_primary()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->primary_); - } - - // .eqproto.Texture Secondary = 9; - if (this->has_secondary()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->secondary_); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void TextureProfile::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.TextureProfile) - GOOGLE_DCHECK_NE(&from, this); - const TextureProfile* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.TextureProfile) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.TextureProfile) - MergeFrom(*source); - } -} - -void TextureProfile::MergeFrom(const TextureProfile& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.TextureProfile) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_head()) { - mutable_head()->::eqproto::Texture::MergeFrom(from.head()); - } - if (from.has_chest()) { - mutable_chest()->::eqproto::Texture::MergeFrom(from.chest()); - } - if (from.has_arms()) { - mutable_arms()->::eqproto::Texture::MergeFrom(from.arms()); - } - if (from.has_wrist()) { - mutable_wrist()->::eqproto::Texture::MergeFrom(from.wrist()); - } - if (from.has_hands()) { - mutable_hands()->::eqproto::Texture::MergeFrom(from.hands()); - } - if (from.has_legs()) { - mutable_legs()->::eqproto::Texture::MergeFrom(from.legs()); - } - if (from.has_feet()) { - mutable_feet()->::eqproto::Texture::MergeFrom(from.feet()); - } - if (from.has_primary()) { - mutable_primary()->::eqproto::Texture::MergeFrom(from.primary()); - } - if (from.has_secondary()) { - mutable_secondary()->::eqproto::Texture::MergeFrom(from.secondary()); - } -} - -void TextureProfile::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.TextureProfile) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void TextureProfile::CopyFrom(const TextureProfile& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.TextureProfile) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TextureProfile::IsInitialized() const { - return true; -} - -void TextureProfile::Swap(TextureProfile* other) { - if (other == this) return; - InternalSwap(other); -} -void TextureProfile::InternalSwap(TextureProfile* other) { - using std::swap; - swap(head_, other->head_); - swap(chest_, other->chest_); - swap(arms_, other->arms_); - swap(wrist_, other->wrist_); - swap(hands_, other->hands_); - swap(legs_, other->legs_); - swap(feet_, other->feet_); - swap(primary_, other->primary_); - swap(secondary_, other->secondary_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata TextureProfile::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Texture::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Texture::kMaterialFieldNumber; -const int Texture::kUnknown1FieldNumber; -const int Texture::kEliteModelFieldNumber; -const int Texture::kHerosForgeModelFieldNumber; -const int Texture::kUnknown2FieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Texture::Texture() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsTexture(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Texture) -} -Texture::Texture(const Texture& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&material_, &from.material_, - static_cast(reinterpret_cast(&unknown2_) - - reinterpret_cast(&material_)) + sizeof(unknown2_)); - // @@protoc_insertion_point(copy_constructor:eqproto.Texture) -} - -void Texture::SharedCtor() { - ::memset(&material_, 0, static_cast( - reinterpret_cast(&unknown2_) - - reinterpret_cast(&material_)) + sizeof(unknown2_)); - _cached_size_ = 0; -} - -Texture::~Texture() { - // @@protoc_insertion_point(destructor:eqproto.Texture) - SharedDtor(); -} - -void Texture::SharedDtor() { -} - -void Texture::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Texture::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Texture& Texture::default_instance() { - ::protobuf_message_2eproto::InitDefaultsTexture(); - return *internal_default_instance(); -} - -Texture* Texture::New(::google::protobuf::Arena* arena) const { - Texture* n = new Texture; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Texture::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Texture) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&material_, 0, static_cast( - reinterpret_cast(&unknown2_) - - reinterpret_cast(&material_)) + sizeof(unknown2_)); - _internal_metadata_.Clear(); -} - -bool Texture::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Texture) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 material = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &material_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown1 = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown1_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 EliteModel = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &elitemodel_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 HerosForgeModel = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &herosforgemodel_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 Unknown2 = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown2_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Texture) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Texture) - return false; -#undef DO_ -} - -void Texture::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Texture) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 material = 1; - if (this->material() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->material(), output); - } - - // uint32 unknown1 = 2; - if (this->unknown1() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->unknown1(), output); - } - - // uint32 EliteModel = 3; - if (this->elitemodel() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->elitemodel(), output); - } - - // uint32 HerosForgeModel = 4; - if (this->herosforgemodel() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->herosforgemodel(), output); - } - - // uint32 Unknown2 = 5; - if (this->unknown2() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->unknown2(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Texture) -} - -::google::protobuf::uint8* Texture::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Texture) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 material = 1; - if (this->material() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->material(), target); - } - - // uint32 unknown1 = 2; - if (this->unknown1() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->unknown1(), target); - } - - // uint32 EliteModel = 3; - if (this->elitemodel() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->elitemodel(), target); - } - - // uint32 HerosForgeModel = 4; - if (this->herosforgemodel() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->herosforgemodel(), target); - } - - // uint32 Unknown2 = 5; - if (this->unknown2() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->unknown2(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Texture) - return target; -} - -size_t Texture::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Texture) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 material = 1; - if (this->material() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->material()); - } - - // uint32 unknown1 = 2; - if (this->unknown1() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown1()); - } - - // uint32 EliteModel = 3; - if (this->elitemodel() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->elitemodel()); - } - - // uint32 HerosForgeModel = 4; - if (this->herosforgemodel() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->herosforgemodel()); - } - - // uint32 Unknown2 = 5; - if (this->unknown2() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown2()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Texture::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Texture) - GOOGLE_DCHECK_NE(&from, this); - const Texture* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Texture) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Texture) - MergeFrom(*source); - } -} - -void Texture::MergeFrom(const Texture& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Texture) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.material() != 0) { - set_material(from.material()); - } - if (from.unknown1() != 0) { - set_unknown1(from.unknown1()); - } - if (from.elitemodel() != 0) { - set_elitemodel(from.elitemodel()); - } - if (from.herosforgemodel() != 0) { - set_herosforgemodel(from.herosforgemodel()); - } - if (from.unknown2() != 0) { - set_unknown2(from.unknown2()); - } -} - -void Texture::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Texture) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Texture::CopyFrom(const Texture& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Texture) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Texture::IsInitialized() const { - return true; -} - -void Texture::Swap(Texture* other) { - if (other == this) return; - InternalSwap(other); -} -void Texture::InternalSwap(Texture* other) { - using std::swap; - swap(material_, other->material_); - swap(unknown1_, other->unknown1_); - swap(elitemodel_, other->elitemodel_); - swap(herosforgemodel_, other->herosforgemodel_); - swap(unknown2_, other->unknown2_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Texture::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void TintProfile::InitAsDefaultInstance() { - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->head_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->chest_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->arms_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->wrist_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->hands_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->legs_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->feet_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->primary_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); - ::eqproto::_TintProfile_default_instance_._instance.get_mutable()->secondary_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int TintProfile::kHeadFieldNumber; -const int TintProfile::kChestFieldNumber; -const int TintProfile::kArmsFieldNumber; -const int TintProfile::kWristFieldNumber; -const int TintProfile::kHandsFieldNumber; -const int TintProfile::kLegsFieldNumber; -const int TintProfile::kFeetFieldNumber; -const int TintProfile::kPrimaryFieldNumber; -const int TintProfile::kSecondaryFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -TintProfile::TintProfile() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsTintProfile(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.TintProfile) -} -TintProfile::TintProfile(const TintProfile& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - if (from.has_head()) { - head_ = new ::eqproto::Tint(*from.head_); - } else { - head_ = NULL; - } - if (from.has_chest()) { - chest_ = new ::eqproto::Tint(*from.chest_); - } else { - chest_ = NULL; - } - if (from.has_arms()) { - arms_ = new ::eqproto::Tint(*from.arms_); - } else { - arms_ = NULL; - } - if (from.has_wrist()) { - wrist_ = new ::eqproto::Tint(*from.wrist_); - } else { - wrist_ = NULL; - } - if (from.has_hands()) { - hands_ = new ::eqproto::Tint(*from.hands_); - } else { - hands_ = NULL; - } - if (from.has_legs()) { - legs_ = new ::eqproto::Tint(*from.legs_); - } else { - legs_ = NULL; - } - if (from.has_feet()) { - feet_ = new ::eqproto::Tint(*from.feet_); - } else { - feet_ = NULL; - } - if (from.has_primary()) { - primary_ = new ::eqproto::Tint(*from.primary_); - } else { - primary_ = NULL; - } - if (from.has_secondary()) { - secondary_ = new ::eqproto::Tint(*from.secondary_); - } else { - secondary_ = NULL; - } - // @@protoc_insertion_point(copy_constructor:eqproto.TintProfile) -} - -void TintProfile::SharedCtor() { - ::memset(&head_, 0, static_cast( - reinterpret_cast(&secondary_) - - reinterpret_cast(&head_)) + sizeof(secondary_)); - _cached_size_ = 0; -} - -TintProfile::~TintProfile() { - // @@protoc_insertion_point(destructor:eqproto.TintProfile) - SharedDtor(); -} - -void TintProfile::SharedDtor() { - if (this != internal_default_instance()) delete head_; - if (this != internal_default_instance()) delete chest_; - if (this != internal_default_instance()) delete arms_; - if (this != internal_default_instance()) delete wrist_; - if (this != internal_default_instance()) delete hands_; - if (this != internal_default_instance()) delete legs_; - if (this != internal_default_instance()) delete feet_; - if (this != internal_default_instance()) delete primary_; - if (this != internal_default_instance()) delete secondary_; -} - -void TintProfile::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* TintProfile::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const TintProfile& TintProfile::default_instance() { - ::protobuf_message_2eproto::InitDefaultsTintProfile(); - return *internal_default_instance(); -} - -TintProfile* TintProfile::New(::google::protobuf::Arena* arena) const { - TintProfile* n = new TintProfile; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void TintProfile::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.TintProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaNoVirtual() == NULL && head_ != NULL) { - delete head_; - } - head_ = NULL; - if (GetArenaNoVirtual() == NULL && chest_ != NULL) { - delete chest_; - } - chest_ = NULL; - if (GetArenaNoVirtual() == NULL && arms_ != NULL) { - delete arms_; - } - arms_ = NULL; - if (GetArenaNoVirtual() == NULL && wrist_ != NULL) { - delete wrist_; - } - wrist_ = NULL; - if (GetArenaNoVirtual() == NULL && hands_ != NULL) { - delete hands_; - } - hands_ = NULL; - if (GetArenaNoVirtual() == NULL && legs_ != NULL) { - delete legs_; - } - legs_ = NULL; - if (GetArenaNoVirtual() == NULL && feet_ != NULL) { - delete feet_; - } - feet_ = NULL; - if (GetArenaNoVirtual() == NULL && primary_ != NULL) { - delete primary_; - } - primary_ = NULL; - if (GetArenaNoVirtual() == NULL && secondary_ != NULL) { - delete secondary_; - } - secondary_ = NULL; - _internal_metadata_.Clear(); -} - -bool TintProfile::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.TintProfile) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // .eqproto.Tint Head = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_head())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Chest = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_chest())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Arms = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(26u /* 26 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_arms())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Wrist = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(34u /* 34 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_wrist())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Hands = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(42u /* 42 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_hands())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Legs = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(50u /* 50 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_legs())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Feet = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_feet())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Primary = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_primary())); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint Secondary = 9; - case 9: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(74u /* 74 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_secondary())); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.TintProfile) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.TintProfile) - return false; -#undef DO_ -} - -void TintProfile::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.TintProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.Tint Head = 1; - if (this->has_head()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 1, *this->head_, output); - } - - // .eqproto.Tint Chest = 2; - if (this->has_chest()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 2, *this->chest_, output); - } - - // .eqproto.Tint Arms = 3; - if (this->has_arms()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 3, *this->arms_, output); - } - - // .eqproto.Tint Wrist = 4; - if (this->has_wrist()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 4, *this->wrist_, output); - } - - // .eqproto.Tint Hands = 5; - if (this->has_hands()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 5, *this->hands_, output); - } - - // .eqproto.Tint Legs = 6; - if (this->has_legs()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 6, *this->legs_, output); - } - - // .eqproto.Tint Feet = 7; - if (this->has_feet()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 7, *this->feet_, output); - } - - // .eqproto.Tint Primary = 8; - if (this->has_primary()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 8, *this->primary_, output); - } - - // .eqproto.Tint Secondary = 9; - if (this->has_secondary()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 9, *this->secondary_, output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.TintProfile) -} - -::google::protobuf::uint8* TintProfile::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.TintProfile) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.Tint Head = 1; - if (this->has_head()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 1, *this->head_, deterministic, target); - } - - // .eqproto.Tint Chest = 2; - if (this->has_chest()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 2, *this->chest_, deterministic, target); - } - - // .eqproto.Tint Arms = 3; - if (this->has_arms()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 3, *this->arms_, deterministic, target); - } - - // .eqproto.Tint Wrist = 4; - if (this->has_wrist()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 4, *this->wrist_, deterministic, target); - } - - // .eqproto.Tint Hands = 5; - if (this->has_hands()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 5, *this->hands_, deterministic, target); - } - - // .eqproto.Tint Legs = 6; - if (this->has_legs()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 6, *this->legs_, deterministic, target); - } - - // .eqproto.Tint Feet = 7; - if (this->has_feet()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 7, *this->feet_, deterministic, target); - } - - // .eqproto.Tint Primary = 8; - if (this->has_primary()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 8, *this->primary_, deterministic, target); - } - - // .eqproto.Tint Secondary = 9; - if (this->has_secondary()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 9, *this->secondary_, deterministic, target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.TintProfile) - return target; -} - -size_t TintProfile::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.TintProfile) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // .eqproto.Tint Head = 1; - if (this->has_head()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->head_); - } - - // .eqproto.Tint Chest = 2; - if (this->has_chest()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->chest_); - } - - // .eqproto.Tint Arms = 3; - if (this->has_arms()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->arms_); - } - - // .eqproto.Tint Wrist = 4; - if (this->has_wrist()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->wrist_); - } - - // .eqproto.Tint Hands = 5; - if (this->has_hands()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->hands_); - } - - // .eqproto.Tint Legs = 6; - if (this->has_legs()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->legs_); - } - - // .eqproto.Tint Feet = 7; - if (this->has_feet()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->feet_); - } - - // .eqproto.Tint Primary = 8; - if (this->has_primary()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->primary_); - } - - // .eqproto.Tint Secondary = 9; - if (this->has_secondary()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->secondary_); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void TintProfile::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.TintProfile) - GOOGLE_DCHECK_NE(&from, this); - const TintProfile* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.TintProfile) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.TintProfile) - MergeFrom(*source); - } -} - -void TintProfile::MergeFrom(const TintProfile& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.TintProfile) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_head()) { - mutable_head()->::eqproto::Tint::MergeFrom(from.head()); - } - if (from.has_chest()) { - mutable_chest()->::eqproto::Tint::MergeFrom(from.chest()); - } - if (from.has_arms()) { - mutable_arms()->::eqproto::Tint::MergeFrom(from.arms()); - } - if (from.has_wrist()) { - mutable_wrist()->::eqproto::Tint::MergeFrom(from.wrist()); - } - if (from.has_hands()) { - mutable_hands()->::eqproto::Tint::MergeFrom(from.hands()); - } - if (from.has_legs()) { - mutable_legs()->::eqproto::Tint::MergeFrom(from.legs()); - } - if (from.has_feet()) { - mutable_feet()->::eqproto::Tint::MergeFrom(from.feet()); - } - if (from.has_primary()) { - mutable_primary()->::eqproto::Tint::MergeFrom(from.primary()); - } - if (from.has_secondary()) { - mutable_secondary()->::eqproto::Tint::MergeFrom(from.secondary()); - } -} - -void TintProfile::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.TintProfile) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void TintProfile::CopyFrom(const TintProfile& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.TintProfile) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool TintProfile::IsInitialized() const { - return true; -} - -void TintProfile::Swap(TintProfile* other) { - if (other == this) return; - InternalSwap(other); -} -void TintProfile::InternalSwap(TintProfile* other) { - using std::swap; - swap(head_, other->head_); - swap(chest_, other->chest_); - swap(arms_, other->arms_); - swap(wrist_, other->wrist_); - swap(hands_, other->hands_); - swap(legs_, other->legs_); - swap(feet_, other->feet_); - swap(primary_, other->primary_); - swap(secondary_, other->secondary_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata TintProfile::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Tint::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Tint::kBlueFieldNumber; -const int Tint::kGreenFieldNumber; -const int Tint::kRedFieldNumber; -const int Tint::kUseTintFieldNumber; -const int Tint::kColorFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Tint::Tint() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsTint(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Tint) -} -Tint::Tint(const Tint& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&blue_, &from.blue_, - static_cast(reinterpret_cast(&color_) - - reinterpret_cast(&blue_)) + sizeof(color_)); - // @@protoc_insertion_point(copy_constructor:eqproto.Tint) -} - -void Tint::SharedCtor() { - ::memset(&blue_, 0, static_cast( - reinterpret_cast(&color_) - - reinterpret_cast(&blue_)) + sizeof(color_)); - _cached_size_ = 0; -} - -Tint::~Tint() { - // @@protoc_insertion_point(destructor:eqproto.Tint) - SharedDtor(); -} - -void Tint::SharedDtor() { -} - -void Tint::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Tint::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Tint& Tint::default_instance() { - ::protobuf_message_2eproto::InitDefaultsTint(); - return *internal_default_instance(); -} - -Tint* Tint::New(::google::protobuf::Arena* arena) const { - Tint* n = new Tint; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Tint::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Tint) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&blue_, 0, static_cast( - reinterpret_cast(&color_) - - reinterpret_cast(&blue_)) + sizeof(color_)); - _internal_metadata_.Clear(); -} - -bool Tint::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Tint) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 Blue = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &blue_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 Green = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &green_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 Red = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &red_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 UseTint = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &usetint_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 Color = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &color_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Tint) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Tint) - return false; -#undef DO_ -} - -void Tint::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Tint) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 Blue = 1; - if (this->blue() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->blue(), output); - } - - // uint32 Green = 2; - if (this->green() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->green(), output); - } - - // uint32 Red = 3; - if (this->red() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->red(), output); - } - - // uint32 UseTint = 4; - if (this->usetint() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->usetint(), output); - } - - // uint32 Color = 5; - if (this->color() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->color(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Tint) -} - -::google::protobuf::uint8* Tint::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Tint) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 Blue = 1; - if (this->blue() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->blue(), target); - } - - // uint32 Green = 2; - if (this->green() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->green(), target); - } - - // uint32 Red = 3; - if (this->red() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->red(), target); - } - - // uint32 UseTint = 4; - if (this->usetint() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->usetint(), target); - } - - // uint32 Color = 5; - if (this->color() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->color(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Tint) - return target; -} - -size_t Tint::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Tint) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 Blue = 1; - if (this->blue() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->blue()); - } - - // uint32 Green = 2; - if (this->green() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->green()); - } - - // uint32 Red = 3; - if (this->red() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->red()); - } - - // uint32 UseTint = 4; - if (this->usetint() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->usetint()); - } - - // uint32 Color = 5; - if (this->color() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->color()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Tint::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Tint) - GOOGLE_DCHECK_NE(&from, this); - const Tint* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Tint) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Tint) - MergeFrom(*source); - } -} - -void Tint::MergeFrom(const Tint& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Tint) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.blue() != 0) { - set_blue(from.blue()); - } - if (from.green() != 0) { - set_green(from.green()); - } - if (from.red() != 0) { - set_red(from.red()); - } - if (from.usetint() != 0) { - set_usetint(from.usetint()); - } - if (from.color() != 0) { - set_color(from.color()); - } -} - -void Tint::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Tint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Tint::CopyFrom(const Tint& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Tint) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Tint::IsInitialized() const { - return true; -} - -void Tint::Swap(Tint* other) { - if (other == this) return; - InternalSwap(other); -} -void Tint::InternalSwap(Tint* other) { - using std::swap; - swap(blue_, other->blue_); - swap(green_, other->green_); - swap(red_, other->red_); - swap(usetint_, other->usetint_); - swap(color_, other->color_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Tint::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void Event::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int Event::kOpFieldNumber; -const int Event::kPayloadFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -Event::Event() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.Event) -} -Event::Event(const Event& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.payload().size() > 0) { - payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_); - } - op_ = from.op_; - // @@protoc_insertion_point(copy_constructor:eqproto.Event) -} - -void Event::SharedCtor() { - payload_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - op_ = 0; - _cached_size_ = 0; -} - -Event::~Event() { - // @@protoc_insertion_point(destructor:eqproto.Event) - SharedDtor(); -} - -void Event::SharedDtor() { - payload_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} - -void Event::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* Event::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const Event& Event::default_instance() { - ::protobuf_message_2eproto::InitDefaultsEvent(); - return *internal_default_instance(); -} - -Event* Event::New(::google::protobuf::Arena* arena) const { - Event* n = new Event; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void Event::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.Event) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - op_ = 0; - _internal_metadata_.Clear(); -} - -bool Event::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.Event) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // .eqproto.OpCode op = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - int value; - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( - input, &value))); - set_op(static_cast< ::eqproto::OpCode >(value)); - } else { - goto handle_unusual; - } - break; - } - - // bytes payload = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadBytes( - input, this->mutable_payload())); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.Event) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.Event) - return false; -#undef DO_ -} - -void Event::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.Event) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.OpCode op = 1; - if (this->op() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteEnum( - 1, this->op(), output); - } - - // bytes payload = 2; - if (this->payload().size() > 0) { - ::google::protobuf::internal::WireFormatLite::WriteBytesMaybeAliased( - 2, this->payload(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.Event) -} - -::google::protobuf::uint8* Event::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.Event) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // .eqproto.OpCode op = 1; - if (this->op() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( - 1, this->op(), target); - } - - // bytes payload = 2; - if (this->payload().size() > 0) { - target = - ::google::protobuf::internal::WireFormatLite::WriteBytesToArray( - 2, this->payload(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.Event) - return target; -} - -size_t Event::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.Event) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // bytes payload = 2; - if (this->payload().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::BytesSize( - this->payload()); - } - - // .eqproto.OpCode op = 1; - if (this->op() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::EnumSize(this->op()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void Event::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.Event) - GOOGLE_DCHECK_NE(&from, this); - const Event* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.Event) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.Event) - MergeFrom(*source); - } -} - -void Event::MergeFrom(const Event& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.Event) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.payload().size() > 0) { - - payload_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.payload_); - } - if (from.op() != 0) { - set_op(from.op()); - } -} - -void Event::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.Event) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void Event::CopyFrom(const Event& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.Event) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool Event::IsInitialized() const { - return true; -} - -void Event::Swap(Event* other) { - if (other == this) return; - InternalSwap(other); -} -void Event::InternalSwap(Event* other) { - using std::swap; - payload_.Swap(&other->payload_); - swap(op_, other->op_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata Event::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void DeathEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int DeathEvent::kSpawnIdFieldNumber; -const int DeathEvent::kKillerIdFieldNumber; -const int DeathEvent::kCorpseIdFieldNumber; -const int DeathEvent::kBindZoneIdFieldNumber; -const int DeathEvent::kSpellIdFieldNumber; -const int DeathEvent::kAttackSkillIdFieldNumber; -const int DeathEvent::kDamageFieldNumber; -const int DeathEvent::kUnknown028FieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -DeathEvent::DeathEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsDeathEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.DeathEvent) -} -DeathEvent::DeathEvent(const DeathEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&spawn_id_, &from.spawn_id_, - static_cast(reinterpret_cast(&unknown028_) - - reinterpret_cast(&spawn_id_)) + sizeof(unknown028_)); - // @@protoc_insertion_point(copy_constructor:eqproto.DeathEvent) -} - -void DeathEvent::SharedCtor() { - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&unknown028_) - - reinterpret_cast(&spawn_id_)) + sizeof(unknown028_)); - _cached_size_ = 0; -} - -DeathEvent::~DeathEvent() { - // @@protoc_insertion_point(destructor:eqproto.DeathEvent) - SharedDtor(); -} - -void DeathEvent::SharedDtor() { -} - -void DeathEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* DeathEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const DeathEvent& DeathEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsDeathEvent(); - return *internal_default_instance(); -} - -DeathEvent* DeathEvent::New(::google::protobuf::Arena* arena) const { - DeathEvent* n = new DeathEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void DeathEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.DeathEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&unknown028_) - - reinterpret_cast(&spawn_id_)) + sizeof(unknown028_)); - _internal_metadata_.Clear(); -} - -bool DeathEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.DeathEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawn_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawn_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 killer_id = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &killer_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 corpse_id = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &corpse_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 bind_zone_id = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &bind_zone_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 spell_id = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spell_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 attack_skill_id = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &attack_skill_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 damage = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &damage_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown028 = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown028_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.DeathEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.DeathEvent) - return false; -#undef DO_ -} - -void DeathEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.DeathEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawn_id(), output); - } - - // uint32 killer_id = 2; - if (this->killer_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->killer_id(), output); - } - - // uint32 corpse_id = 3; - if (this->corpse_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->corpse_id(), output); - } - - // uint32 bind_zone_id = 4; - if (this->bind_zone_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->bind_zone_id(), output); - } - - // uint32 spell_id = 5; - if (this->spell_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->spell_id(), output); - } - - // uint32 attack_skill_id = 6; - if (this->attack_skill_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->attack_skill_id(), output); - } - - // uint32 damage = 7; - if (this->damage() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->damage(), output); - } - - // uint32 unknown028 = 8; - if (this->unknown028() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->unknown028(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.DeathEvent) -} - -::google::protobuf::uint8* DeathEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.DeathEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawn_id(), target); - } - - // uint32 killer_id = 2; - if (this->killer_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->killer_id(), target); - } - - // uint32 corpse_id = 3; - if (this->corpse_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->corpse_id(), target); - } - - // uint32 bind_zone_id = 4; - if (this->bind_zone_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->bind_zone_id(), target); - } - - // uint32 spell_id = 5; - if (this->spell_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->spell_id(), target); - } - - // uint32 attack_skill_id = 6; - if (this->attack_skill_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->attack_skill_id(), target); - } - - // uint32 damage = 7; - if (this->damage() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->damage(), target); - } - - // uint32 unknown028 = 8; - if (this->unknown028() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->unknown028(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.DeathEvent) - return target; -} - -size_t DeathEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.DeathEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawn_id()); - } - - // uint32 killer_id = 2; - if (this->killer_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->killer_id()); - } - - // uint32 corpse_id = 3; - if (this->corpse_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->corpse_id()); - } - - // uint32 bind_zone_id = 4; - if (this->bind_zone_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->bind_zone_id()); - } - - // uint32 spell_id = 5; - if (this->spell_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spell_id()); - } - - // uint32 attack_skill_id = 6; - if (this->attack_skill_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->attack_skill_id()); - } - - // uint32 damage = 7; - if (this->damage() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->damage()); - } - - // uint32 unknown028 = 8; - if (this->unknown028() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown028()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void DeathEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.DeathEvent) - GOOGLE_DCHECK_NE(&from, this); - const DeathEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.DeathEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.DeathEvent) - MergeFrom(*source); - } -} - -void DeathEvent::MergeFrom(const DeathEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.DeathEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.spawn_id() != 0) { - set_spawn_id(from.spawn_id()); - } - if (from.killer_id() != 0) { - set_killer_id(from.killer_id()); - } - if (from.corpse_id() != 0) { - set_corpse_id(from.corpse_id()); - } - if (from.bind_zone_id() != 0) { - set_bind_zone_id(from.bind_zone_id()); - } - if (from.spell_id() != 0) { - set_spell_id(from.spell_id()); - } - if (from.attack_skill_id() != 0) { - set_attack_skill_id(from.attack_skill_id()); - } - if (from.damage() != 0) { - set_damage(from.damage()); - } - if (from.unknown028() != 0) { - set_unknown028(from.unknown028()); - } -} - -void DeathEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.DeathEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void DeathEvent::CopyFrom(const DeathEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.DeathEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DeathEvent::IsInitialized() const { - return true; -} - -void DeathEvent::Swap(DeathEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void DeathEvent::InternalSwap(DeathEvent* other) { - using std::swap; - swap(spawn_id_, other->spawn_id_); - swap(killer_id_, other->killer_id_); - swap(corpse_id_, other->corpse_id_); - swap(bind_zone_id_, other->bind_zone_id_); - swap(spell_id_, other->spell_id_); - swap(attack_skill_id_, other->attack_skill_id_); - swap(damage_, other->damage_); - swap(unknown028_, other->unknown028_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata DeathEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void DamageEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int DamageEvent::kTargetFieldNumber; -const int DamageEvent::kSourceFieldNumber; -const int DamageEvent::kTypeFieldNumber; -const int DamageEvent::kSpellidFieldNumber; -const int DamageEvent::kDamageFieldNumber; -const int DamageEvent::kForceFieldNumber; -const int DamageEvent::kMeleepushXyFieldNumber; -const int DamageEvent::kMeleepushZFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -DamageEvent::DamageEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsDamageEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.DamageEvent) -} -DamageEvent::DamageEvent(const DamageEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&target_, &from.target_, - static_cast(reinterpret_cast(&meleepush_z_) - - reinterpret_cast(&target_)) + sizeof(meleepush_z_)); - // @@protoc_insertion_point(copy_constructor:eqproto.DamageEvent) -} - -void DamageEvent::SharedCtor() { - ::memset(&target_, 0, static_cast( - reinterpret_cast(&meleepush_z_) - - reinterpret_cast(&target_)) + sizeof(meleepush_z_)); - _cached_size_ = 0; -} - -DamageEvent::~DamageEvent() { - // @@protoc_insertion_point(destructor:eqproto.DamageEvent) - SharedDtor(); -} - -void DamageEvent::SharedDtor() { -} - -void DamageEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* DamageEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const DamageEvent& DamageEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsDamageEvent(); - return *internal_default_instance(); -} - -DamageEvent* DamageEvent::New(::google::protobuf::Arena* arena) const { - DamageEvent* n = new DamageEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void DamageEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.DamageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&target_, 0, static_cast( - reinterpret_cast(&meleepush_z_) - - reinterpret_cast(&target_)) + sizeof(meleepush_z_)); - _internal_metadata_.Clear(); -} - -bool DamageEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.DamageEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 target = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &target_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 source = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &source_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 type = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &type_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 spellid = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spellid_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 damage = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &damage_))); - } else { - goto handle_unusual; - } - break; - } - - // float force = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(53u /* 53 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &force_))); - } else { - goto handle_unusual; - } - break; - } - - // float meleepush_xy = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(61u /* 61 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &meleepush_xy_))); - } else { - goto handle_unusual; - } - break; - } - - // float meleepush_z = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(69u /* 69 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &meleepush_z_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.DamageEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.DamageEvent) - return false; -#undef DO_ -} - -void DamageEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.DamageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 target = 1; - if (this->target() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->target(), output); - } - - // uint32 source = 2; - if (this->source() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->source(), output); - } - - // uint32 type = 3; - if (this->type() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->type(), output); - } - - // uint32 spellid = 4; - if (this->spellid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->spellid(), output); - } - - // uint32 damage = 5; - if (this->damage() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->damage(), output); - } - - // float force = 6; - if (this->force() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(6, this->force(), output); - } - - // float meleepush_xy = 7; - if (this->meleepush_xy() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(7, this->meleepush_xy(), output); - } - - // float meleepush_z = 8; - if (this->meleepush_z() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(8, this->meleepush_z(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.DamageEvent) -} - -::google::protobuf::uint8* DamageEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.DamageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 target = 1; - if (this->target() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->target(), target); - } - - // uint32 source = 2; - if (this->source() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->source(), target); - } - - // uint32 type = 3; - if (this->type() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->type(), target); - } - - // uint32 spellid = 4; - if (this->spellid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->spellid(), target); - } - - // uint32 damage = 5; - if (this->damage() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->damage(), target); - } - - // float force = 6; - if (this->force() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(6, this->force(), target); - } - - // float meleepush_xy = 7; - if (this->meleepush_xy() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(7, this->meleepush_xy(), target); - } - - // float meleepush_z = 8; - if (this->meleepush_z() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(8, this->meleepush_z(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.DamageEvent) - return target; -} - -size_t DamageEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.DamageEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 target = 1; - if (this->target() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->target()); - } - - // uint32 source = 2; - if (this->source() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->source()); - } - - // uint32 type = 3; - if (this->type() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->type()); - } - - // uint32 spellid = 4; - if (this->spellid() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spellid()); - } - - // uint32 damage = 5; - if (this->damage() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->damage()); - } - - // float force = 6; - if (this->force() != 0) { - total_size += 1 + 4; - } - - // float meleepush_xy = 7; - if (this->meleepush_xy() != 0) { - total_size += 1 + 4; - } - - // float meleepush_z = 8; - if (this->meleepush_z() != 0) { - total_size += 1 + 4; - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void DamageEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.DamageEvent) - GOOGLE_DCHECK_NE(&from, this); - const DamageEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.DamageEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.DamageEvent) - MergeFrom(*source); - } -} - -void DamageEvent::MergeFrom(const DamageEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.DamageEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.target() != 0) { - set_target(from.target()); - } - if (from.source() != 0) { - set_source(from.source()); - } - if (from.type() != 0) { - set_type(from.type()); - } - if (from.spellid() != 0) { - set_spellid(from.spellid()); - } - if (from.damage() != 0) { - set_damage(from.damage()); - } - if (from.force() != 0) { - set_force(from.force()); - } - if (from.meleepush_xy() != 0) { - set_meleepush_xy(from.meleepush_xy()); - } - if (from.meleepush_z() != 0) { - set_meleepush_z(from.meleepush_z()); - } -} - -void DamageEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.DamageEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void DamageEvent::CopyFrom(const DamageEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.DamageEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DamageEvent::IsInitialized() const { - return true; -} - -void DamageEvent::Swap(DamageEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void DamageEvent::InternalSwap(DamageEvent* other) { - using std::swap; - swap(target_, other->target_); - swap(source_, other->source_); - swap(type_, other->type_); - swap(spellid_, other->spellid_); - swap(damage_, other->damage_); - swap(force_, other->force_); - swap(meleepush_xy_, other->meleepush_xy_); - swap(meleepush_z_, other->meleepush_z_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata DamageEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void EntityEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int EntityEvent::kEntityIdFieldNumber; -const int EntityEvent::kTargetIdFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -EntityEvent::EntityEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsEntityEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.EntityEvent) -} -EntityEvent::EntityEvent(const EntityEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&entity_id_, &from.entity_id_, - static_cast(reinterpret_cast(&target_id_) - - reinterpret_cast(&entity_id_)) + sizeof(target_id_)); - // @@protoc_insertion_point(copy_constructor:eqproto.EntityEvent) -} - -void EntityEvent::SharedCtor() { - ::memset(&entity_id_, 0, static_cast( - reinterpret_cast(&target_id_) - - reinterpret_cast(&entity_id_)) + sizeof(target_id_)); - _cached_size_ = 0; -} - -EntityEvent::~EntityEvent() { - // @@protoc_insertion_point(destructor:eqproto.EntityEvent) - SharedDtor(); -} - -void EntityEvent::SharedDtor() { -} - -void EntityEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* EntityEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const EntityEvent& EntityEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsEntityEvent(); - return *internal_default_instance(); -} - -EntityEvent* EntityEvent::New(::google::protobuf::Arena* arena) const { - EntityEvent* n = new EntityEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void EntityEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.EntityEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&entity_id_, 0, static_cast( - reinterpret_cast(&target_id_) - - reinterpret_cast(&entity_id_)) + sizeof(target_id_)); - _internal_metadata_.Clear(); -} - -bool EntityEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.EntityEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 entity_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &entity_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 target_id = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &target_id_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.EntityEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.EntityEvent) - return false; -#undef DO_ -} - -void EntityEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.EntityEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 entity_id = 1; - if (this->entity_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->entity_id(), output); - } - - // uint32 target_id = 2; - if (this->target_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->target_id(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.EntityEvent) -} - -::google::protobuf::uint8* EntityEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.EntityEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 entity_id = 1; - if (this->entity_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->entity_id(), target); - } - - // uint32 target_id = 2; - if (this->target_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->target_id(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.EntityEvent) - return target; -} - -size_t EntityEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.EntityEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 entity_id = 1; - if (this->entity_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->entity_id()); - } - - // uint32 target_id = 2; - if (this->target_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->target_id()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void EntityEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.EntityEvent) - GOOGLE_DCHECK_NE(&from, this); - const EntityEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.EntityEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.EntityEvent) - MergeFrom(*source); - } -} - -void EntityEvent::MergeFrom(const EntityEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.EntityEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.entity_id() != 0) { - set_entity_id(from.entity_id()); - } - if (from.target_id() != 0) { - set_target_id(from.target_id()); - } -} - -void EntityEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.EntityEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void EntityEvent::CopyFrom(const EntityEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.EntityEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool EntityEvent::IsInitialized() const { - return true; -} - -void EntityEvent::Swap(EntityEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void EntityEvent::InternalSwap(EntityEvent* other) { - using std::swap; - swap(entity_id_, other->entity_id_); - swap(target_id_, other->target_id_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata EntityEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void ChannelMessageEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int ChannelMessageEvent::kTargetNameFieldNumber; -const int ChannelMessageEvent::kSenderFieldNumber; -const int ChannelMessageEvent::kLanguageFieldNumber; -const int ChannelMessageEvent::kChanNumFieldNumber; -const int ChannelMessageEvent::kCmUnknown4FieldNumber; -const int ChannelMessageEvent::kSkillInLanguageFieldNumber; -const int ChannelMessageEvent::kMessageFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -ChannelMessageEvent::ChannelMessageEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsChannelMessageEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.ChannelMessageEvent) -} -ChannelMessageEvent::ChannelMessageEvent(const ChannelMessageEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - target_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.target_name().size() > 0) { - target_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.target_name_); - } - sender_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.sender().size() > 0) { - sender_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.sender_); - } - message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.message().size() > 0) { - message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_); - } - ::memcpy(&language_, &from.language_, - static_cast(reinterpret_cast(&skill_in_language_) - - reinterpret_cast(&language_)) + sizeof(skill_in_language_)); - // @@protoc_insertion_point(copy_constructor:eqproto.ChannelMessageEvent) -} - -void ChannelMessageEvent::SharedCtor() { - target_name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - sender_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&language_, 0, static_cast( - reinterpret_cast(&skill_in_language_) - - reinterpret_cast(&language_)) + sizeof(skill_in_language_)); - _cached_size_ = 0; -} - -ChannelMessageEvent::~ChannelMessageEvent() { - // @@protoc_insertion_point(destructor:eqproto.ChannelMessageEvent) - SharedDtor(); -} - -void ChannelMessageEvent::SharedDtor() { - target_name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - sender_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} - -void ChannelMessageEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* ChannelMessageEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const ChannelMessageEvent& ChannelMessageEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsChannelMessageEvent(); - return *internal_default_instance(); -} - -ChannelMessageEvent* ChannelMessageEvent::New(::google::protobuf::Arena* arena) const { - ChannelMessageEvent* n = new ChannelMessageEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void ChannelMessageEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.ChannelMessageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - target_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - sender_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&language_, 0, static_cast( - reinterpret_cast(&skill_in_language_) - - reinterpret_cast(&language_)) + sizeof(skill_in_language_)); - _internal_metadata_.Clear(); -} - -bool ChannelMessageEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.ChannelMessageEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // string target_name = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(10u /* 10 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_target_name())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->target_name().data(), static_cast(this->target_name().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessageEvent.target_name")); - } else { - goto handle_unusual; - } - break; - } - - // string sender = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(18u /* 18 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_sender())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->sender().data(), static_cast(this->sender().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessageEvent.sender")); - } else { - goto handle_unusual; - } - break; - } - - // uint32 language = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &language_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 chan_num = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &chan_num_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 cm_unknown4 = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &cm_unknown4_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 skill_in_language = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &skill_in_language_))); - } else { - goto handle_unusual; - } - break; - } - - // string message = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_message())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.ChannelMessageEvent.message")); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.ChannelMessageEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.ChannelMessageEvent) - return false; -#undef DO_ -} - -void ChannelMessageEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.ChannelMessageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string target_name = 1; - if (this->target_name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->target_name().data(), static_cast(this->target_name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.target_name"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 1, this->target_name(), output); - } - - // string sender = 2; - if (this->sender().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->sender().data(), static_cast(this->sender().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.sender"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 2, this->sender(), output); - } - - // uint32 language = 3; - if (this->language() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->language(), output); - } - - // uint32 chan_num = 4; - if (this->chan_num() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->chan_num(), output); - } - - // uint32 cm_unknown4 = 5; - if (this->cm_unknown4() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->cm_unknown4(), output); - } - - // uint32 skill_in_language = 6; - if (this->skill_in_language() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->skill_in_language(), output); - } - - // string message = 7; - if (this->message().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.message"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 7, this->message(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.ChannelMessageEvent) -} - -::google::protobuf::uint8* ChannelMessageEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.ChannelMessageEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // string target_name = 1; - if (this->target_name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->target_name().data(), static_cast(this->target_name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.target_name"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 1, this->target_name(), target); - } - - // string sender = 2; - if (this->sender().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->sender().data(), static_cast(this->sender().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.sender"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 2, this->sender(), target); - } - - // uint32 language = 3; - if (this->language() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->language(), target); - } - - // uint32 chan_num = 4; - if (this->chan_num() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->chan_num(), target); - } - - // uint32 cm_unknown4 = 5; - if (this->cm_unknown4() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->cm_unknown4(), target); - } - - // uint32 skill_in_language = 6; - if (this->skill_in_language() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->skill_in_language(), target); - } - - // string message = 7; - if (this->message().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->message().data(), static_cast(this->message().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.ChannelMessageEvent.message"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 7, this->message(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.ChannelMessageEvent) - return target; -} - -size_t ChannelMessageEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.ChannelMessageEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // string target_name = 1; - if (this->target_name().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->target_name()); - } - - // string sender = 2; - if (this->sender().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->sender()); - } - - // string message = 7; - if (this->message().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->message()); - } - - // uint32 language = 3; - if (this->language() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->language()); - } - - // uint32 chan_num = 4; - if (this->chan_num() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->chan_num()); - } - - // uint32 cm_unknown4 = 5; - if (this->cm_unknown4() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->cm_unknown4()); - } - - // uint32 skill_in_language = 6; - if (this->skill_in_language() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->skill_in_language()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void ChannelMessageEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.ChannelMessageEvent) - GOOGLE_DCHECK_NE(&from, this); - const ChannelMessageEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.ChannelMessageEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.ChannelMessageEvent) - MergeFrom(*source); - } -} - -void ChannelMessageEvent::MergeFrom(const ChannelMessageEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.ChannelMessageEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.target_name().size() > 0) { - - target_name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.target_name_); - } - if (from.sender().size() > 0) { - - sender_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.sender_); - } - if (from.message().size() > 0) { - - message_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.message_); - } - if (from.language() != 0) { - set_language(from.language()); - } - if (from.chan_num() != 0) { - set_chan_num(from.chan_num()); - } - if (from.cm_unknown4() != 0) { - set_cm_unknown4(from.cm_unknown4()); - } - if (from.skill_in_language() != 0) { - set_skill_in_language(from.skill_in_language()); - } -} - -void ChannelMessageEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.ChannelMessageEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void ChannelMessageEvent::CopyFrom(const ChannelMessageEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.ChannelMessageEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool ChannelMessageEvent::IsInitialized() const { - return true; -} - -void ChannelMessageEvent::Swap(ChannelMessageEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void ChannelMessageEvent::InternalSwap(ChannelMessageEvent* other) { - using std::swap; - target_name_.Swap(&other->target_name_); - sender_.Swap(&other->sender_); - message_.Swap(&other->message_); - swap(language_, other->language_); - swap(chan_num_, other->chan_num_); - swap(cm_unknown4_, other->cm_unknown4_); - swap(skill_in_language_, other->skill_in_language_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata ChannelMessageEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void WearChangeEvent::InitAsDefaultInstance() { - ::eqproto::_WearChangeEvent_default_instance_._instance.get_mutable()->color_ = const_cast< ::eqproto::Tint*>( - ::eqproto::Tint::internal_default_instance()); -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int WearChangeEvent::kSpawnIdFieldNumber; -const int WearChangeEvent::kMaterialFieldNumber; -const int WearChangeEvent::kUnknown06FieldNumber; -const int WearChangeEvent::kEliteMaterialFieldNumber; -const int WearChangeEvent::kHeroForgeModelFieldNumber; -const int WearChangeEvent::kUnknown18FieldNumber; -const int WearChangeEvent::kColorFieldNumber; -const int WearChangeEvent::kWearSlotIdFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -WearChangeEvent::WearChangeEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsWearChangeEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.WearChangeEvent) -} -WearChangeEvent::WearChangeEvent(const WearChangeEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - if (from.has_color()) { - color_ = new ::eqproto::Tint(*from.color_); - } else { - color_ = NULL; - } - ::memcpy(&spawn_id_, &from.spawn_id_, - static_cast(reinterpret_cast(&wear_slot_id_) - - reinterpret_cast(&spawn_id_)) + sizeof(wear_slot_id_)); - // @@protoc_insertion_point(copy_constructor:eqproto.WearChangeEvent) -} - -void WearChangeEvent::SharedCtor() { - ::memset(&color_, 0, static_cast( - reinterpret_cast(&wear_slot_id_) - - reinterpret_cast(&color_)) + sizeof(wear_slot_id_)); - _cached_size_ = 0; -} - -WearChangeEvent::~WearChangeEvent() { - // @@protoc_insertion_point(destructor:eqproto.WearChangeEvent) - SharedDtor(); -} - -void WearChangeEvent::SharedDtor() { - if (this != internal_default_instance()) delete color_; -} - -void WearChangeEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* WearChangeEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const WearChangeEvent& WearChangeEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsWearChangeEvent(); - return *internal_default_instance(); -} - -WearChangeEvent* WearChangeEvent::New(::google::protobuf::Arena* arena) const { - WearChangeEvent* n = new WearChangeEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void WearChangeEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.WearChangeEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - if (GetArenaNoVirtual() == NULL && color_ != NULL) { - delete color_; - } - color_ = NULL; - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&wear_slot_id_) - - reinterpret_cast(&spawn_id_)) + sizeof(wear_slot_id_)); - _internal_metadata_.Clear(); -} - -bool WearChangeEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.WearChangeEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawn_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawn_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 material = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &material_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown06 = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown06_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 elite_material = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &elite_material_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 hero_forge_model = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &hero_forge_model_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown18 = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown18_))); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.Tint color = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(58u /* 58 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_color())); - } else { - goto handle_unusual; - } - break; - } - - // uint32 wear_slot_id = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &wear_slot_id_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.WearChangeEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.WearChangeEvent) - return false; -#undef DO_ -} - -void WearChangeEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.WearChangeEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawn_id(), output); - } - - // uint32 material = 2; - if (this->material() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->material(), output); - } - - // uint32 unknown06 = 3; - if (this->unknown06() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->unknown06(), output); - } - - // uint32 elite_material = 4; - if (this->elite_material() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->elite_material(), output); - } - - // uint32 hero_forge_model = 5; - if (this->hero_forge_model() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->hero_forge_model(), output); - } - - // uint32 unknown18 = 6; - if (this->unknown18() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->unknown18(), output); - } - - // .eqproto.Tint color = 7; - if (this->has_color()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 7, *this->color_, output); - } - - // uint32 wear_slot_id = 8; - if (this->wear_slot_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(8, this->wear_slot_id(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.WearChangeEvent) -} - -::google::protobuf::uint8* WearChangeEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.WearChangeEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawn_id(), target); - } - - // uint32 material = 2; - if (this->material() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->material(), target); - } - - // uint32 unknown06 = 3; - if (this->unknown06() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->unknown06(), target); - } - - // uint32 elite_material = 4; - if (this->elite_material() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->elite_material(), target); - } - - // uint32 hero_forge_model = 5; - if (this->hero_forge_model() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->hero_forge_model(), target); - } - - // uint32 unknown18 = 6; - if (this->unknown18() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->unknown18(), target); - } - - // .eqproto.Tint color = 7; - if (this->has_color()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 7, *this->color_, deterministic, target); - } - - // uint32 wear_slot_id = 8; - if (this->wear_slot_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(8, this->wear_slot_id(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.WearChangeEvent) - return target; -} - -size_t WearChangeEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.WearChangeEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // .eqproto.Tint color = 7; - if (this->has_color()) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->color_); - } - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawn_id()); - } - - // uint32 material = 2; - if (this->material() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->material()); - } - - // uint32 unknown06 = 3; - if (this->unknown06() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown06()); - } - - // uint32 elite_material = 4; - if (this->elite_material() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->elite_material()); - } - - // uint32 hero_forge_model = 5; - if (this->hero_forge_model() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->hero_forge_model()); - } - - // uint32 unknown18 = 6; - if (this->unknown18() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown18()); - } - - // uint32 wear_slot_id = 8; - if (this->wear_slot_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->wear_slot_id()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void WearChangeEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.WearChangeEvent) - GOOGLE_DCHECK_NE(&from, this); - const WearChangeEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.WearChangeEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.WearChangeEvent) - MergeFrom(*source); - } -} - -void WearChangeEvent::MergeFrom(const WearChangeEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.WearChangeEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.has_color()) { - mutable_color()->::eqproto::Tint::MergeFrom(from.color()); - } - if (from.spawn_id() != 0) { - set_spawn_id(from.spawn_id()); - } - if (from.material() != 0) { - set_material(from.material()); - } - if (from.unknown06() != 0) { - set_unknown06(from.unknown06()); - } - if (from.elite_material() != 0) { - set_elite_material(from.elite_material()); - } - if (from.hero_forge_model() != 0) { - set_hero_forge_model(from.hero_forge_model()); - } - if (from.unknown18() != 0) { - set_unknown18(from.unknown18()); - } - if (from.wear_slot_id() != 0) { - set_wear_slot_id(from.wear_slot_id()); - } -} - -void WearChangeEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.WearChangeEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void WearChangeEvent::CopyFrom(const WearChangeEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.WearChangeEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool WearChangeEvent::IsInitialized() const { - return true; -} - -void WearChangeEvent::Swap(WearChangeEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void WearChangeEvent::InternalSwap(WearChangeEvent* other) { - using std::swap; - swap(color_, other->color_); - swap(spawn_id_, other->spawn_id_); - swap(material_, other->material_); - swap(unknown06_, other->unknown06_); - swap(elite_material_, other->elite_material_); - swap(hero_forge_model_, other->hero_forge_model_); - swap(unknown18_, other->unknown18_); - swap(wear_slot_id_, other->wear_slot_id_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata WearChangeEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void DeleteSpawnEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int DeleteSpawnEvent::kSpawnIdFieldNumber; -const int DeleteSpawnEvent::kDecayFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -DeleteSpawnEvent::DeleteSpawnEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsDeleteSpawnEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.DeleteSpawnEvent) -} -DeleteSpawnEvent::DeleteSpawnEvent(const DeleteSpawnEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&spawn_id_, &from.spawn_id_, - static_cast(reinterpret_cast(&decay_) - - reinterpret_cast(&spawn_id_)) + sizeof(decay_)); - // @@protoc_insertion_point(copy_constructor:eqproto.DeleteSpawnEvent) -} - -void DeleteSpawnEvent::SharedCtor() { - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&decay_) - - reinterpret_cast(&spawn_id_)) + sizeof(decay_)); - _cached_size_ = 0; -} - -DeleteSpawnEvent::~DeleteSpawnEvent() { - // @@protoc_insertion_point(destructor:eqproto.DeleteSpawnEvent) - SharedDtor(); -} - -void DeleteSpawnEvent::SharedDtor() { -} - -void DeleteSpawnEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* DeleteSpawnEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const DeleteSpawnEvent& DeleteSpawnEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsDeleteSpawnEvent(); - return *internal_default_instance(); -} - -DeleteSpawnEvent* DeleteSpawnEvent::New(::google::protobuf::Arena* arena) const { - DeleteSpawnEvent* n = new DeleteSpawnEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void DeleteSpawnEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.DeleteSpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&decay_) - - reinterpret_cast(&spawn_id_)) + sizeof(decay_)); - _internal_metadata_.Clear(); -} - -bool DeleteSpawnEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.DeleteSpawnEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawn_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawn_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 decay = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &decay_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.DeleteSpawnEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.DeleteSpawnEvent) - return false; -#undef DO_ -} - -void DeleteSpawnEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.DeleteSpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawn_id(), output); - } - - // uint32 decay = 2; - if (this->decay() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->decay(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.DeleteSpawnEvent) -} - -::google::protobuf::uint8* DeleteSpawnEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.DeleteSpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawn_id(), target); - } - - // uint32 decay = 2; - if (this->decay() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->decay(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.DeleteSpawnEvent) - return target; -} - -size_t DeleteSpawnEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.DeleteSpawnEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawn_id()); - } - - // uint32 decay = 2; - if (this->decay() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->decay()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void DeleteSpawnEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.DeleteSpawnEvent) - GOOGLE_DCHECK_NE(&from, this); - const DeleteSpawnEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.DeleteSpawnEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.DeleteSpawnEvent) - MergeFrom(*source); - } -} - -void DeleteSpawnEvent::MergeFrom(const DeleteSpawnEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.DeleteSpawnEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.spawn_id() != 0) { - set_spawn_id(from.spawn_id()); - } - if (from.decay() != 0) { - set_decay(from.decay()); - } -} - -void DeleteSpawnEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.DeleteSpawnEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void DeleteSpawnEvent::CopyFrom(const DeleteSpawnEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.DeleteSpawnEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool DeleteSpawnEvent::IsInitialized() const { - return true; -} - -void DeleteSpawnEvent::Swap(DeleteSpawnEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void DeleteSpawnEvent::InternalSwap(DeleteSpawnEvent* other) { - using std::swap; - swap(spawn_id_, other->spawn_id_); - swap(decay_, other->decay_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata DeleteSpawnEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void HPEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int HPEvent::kSpawnIdFieldNumber; -const int HPEvent::kCurHpFieldNumber; -const int HPEvent::kMaxHpFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -HPEvent::HPEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsHPEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.HPEvent) -} -HPEvent::HPEvent(const HPEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&spawn_id_, &from.spawn_id_, - static_cast(reinterpret_cast(&max_hp_) - - reinterpret_cast(&spawn_id_)) + sizeof(max_hp_)); - // @@protoc_insertion_point(copy_constructor:eqproto.HPEvent) -} - -void HPEvent::SharedCtor() { - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&max_hp_) - - reinterpret_cast(&spawn_id_)) + sizeof(max_hp_)); - _cached_size_ = 0; -} - -HPEvent::~HPEvent() { - // @@protoc_insertion_point(destructor:eqproto.HPEvent) - SharedDtor(); -} - -void HPEvent::SharedDtor() { -} - -void HPEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* HPEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const HPEvent& HPEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsHPEvent(); - return *internal_default_instance(); -} - -HPEvent* HPEvent::New(::google::protobuf::Arena* arena) const { - HPEvent* n = new HPEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void HPEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.HPEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&max_hp_) - - reinterpret_cast(&spawn_id_)) + sizeof(max_hp_)); - _internal_metadata_.Clear(); -} - -bool HPEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.HPEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawn_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawn_id_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 cur_hp = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &cur_hp_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 max_hp = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &max_hp_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.HPEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.HPEvent) - return false; -#undef DO_ -} - -void HPEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.HPEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawn_id(), output); - } - - // uint32 cur_hp = 2; - if (this->cur_hp() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->cur_hp(), output); - } - - // uint32 max_hp = 3; - if (this->max_hp() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->max_hp(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.HPEvent) -} - -::google::protobuf::uint8* HPEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.HPEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawn_id(), target); - } - - // uint32 cur_hp = 2; - if (this->cur_hp() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->cur_hp(), target); - } - - // uint32 max_hp = 3; - if (this->max_hp() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->max_hp(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.HPEvent) - return target; -} - -size_t HPEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.HPEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawn_id()); - } - - // uint32 cur_hp = 2; - if (this->cur_hp() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->cur_hp()); - } - - // uint32 max_hp = 3; - if (this->max_hp() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->max_hp()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void HPEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.HPEvent) - GOOGLE_DCHECK_NE(&from, this); - const HPEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.HPEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.HPEvent) - MergeFrom(*source); - } -} - -void HPEvent::MergeFrom(const HPEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.HPEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.spawn_id() != 0) { - set_spawn_id(from.spawn_id()); - } - if (from.cur_hp() != 0) { - set_cur_hp(from.cur_hp()); - } - if (from.max_hp() != 0) { - set_max_hp(from.max_hp()); - } -} - -void HPEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.HPEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void HPEvent::CopyFrom(const HPEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.HPEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool HPEvent::IsInitialized() const { - return true; -} - -void HPEvent::Swap(HPEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void HPEvent::InternalSwap(HPEvent* other) { - using std::swap; - swap(spawn_id_, other->spawn_id_); - swap(cur_hp_, other->cur_hp_); - swap(max_hp_, other->max_hp_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata HPEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void PlayerPositionUpdateEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int PlayerPositionUpdateEvent::kSpawnIdFieldNumber; -const int PlayerPositionUpdateEvent::kDeltaHeadingFieldNumber; -const int PlayerPositionUpdateEvent::kXPosFieldNumber; -const int PlayerPositionUpdateEvent::kPadding0002FieldNumber; -const int PlayerPositionUpdateEvent::kYPosFieldNumber; -const int PlayerPositionUpdateEvent::kAnimationFieldNumber; -const int PlayerPositionUpdateEvent::kPadding0006FieldNumber; -const int PlayerPositionUpdateEvent::kZPosFieldNumber; -const int PlayerPositionUpdateEvent::kDeltaYFieldNumber; -const int PlayerPositionUpdateEvent::kDeltaXFieldNumber; -const int PlayerPositionUpdateEvent::kHeadingFieldNumber; -const int PlayerPositionUpdateEvent::kPadding0014FieldNumber; -const int PlayerPositionUpdateEvent::kDeltaZFieldNumber; -const int PlayerPositionUpdateEvent::kPadding0018FieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -PlayerPositionUpdateEvent::PlayerPositionUpdateEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsPlayerPositionUpdateEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.PlayerPositionUpdateEvent) -} -PlayerPositionUpdateEvent::PlayerPositionUpdateEvent(const PlayerPositionUpdateEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&spawn_id_, &from.spawn_id_, - static_cast(reinterpret_cast(&padding0018_) - - reinterpret_cast(&spawn_id_)) + sizeof(padding0018_)); - // @@protoc_insertion_point(copy_constructor:eqproto.PlayerPositionUpdateEvent) -} - -void PlayerPositionUpdateEvent::SharedCtor() { - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&padding0018_) - - reinterpret_cast(&spawn_id_)) + sizeof(padding0018_)); - _cached_size_ = 0; -} - -PlayerPositionUpdateEvent::~PlayerPositionUpdateEvent() { - // @@protoc_insertion_point(destructor:eqproto.PlayerPositionUpdateEvent) - SharedDtor(); -} - -void PlayerPositionUpdateEvent::SharedDtor() { -} - -void PlayerPositionUpdateEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* PlayerPositionUpdateEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const PlayerPositionUpdateEvent& PlayerPositionUpdateEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsPlayerPositionUpdateEvent(); - return *internal_default_instance(); -} - -PlayerPositionUpdateEvent* PlayerPositionUpdateEvent::New(::google::protobuf::Arena* arena) const { - PlayerPositionUpdateEvent* n = new PlayerPositionUpdateEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void PlayerPositionUpdateEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.PlayerPositionUpdateEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&spawn_id_, 0, static_cast( - reinterpret_cast(&padding0018_) - - reinterpret_cast(&spawn_id_)) + sizeof(padding0018_)); - _internal_metadata_.Clear(); -} - -bool PlayerPositionUpdateEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.PlayerPositionUpdateEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawn_id = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawn_id_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 delta_heading = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &delta_heading_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 x_pos = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &x_pos_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0002 = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0002_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 y_pos = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &y_pos_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 animation = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &animation_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0006 = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0006_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 z_pos = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 64 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &z_pos_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 delta_y = 9; - case 9: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &delta_y_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 delta_x = 10; - case 10: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &delta_x_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 heading = 11; - case 11: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(88u /* 88 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &heading_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0014 = 12; - case 12: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0014_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 delta_z = 13; - case 13: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &delta_z_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0018 = 14; - case 14: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0018_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.PlayerPositionUpdateEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.PlayerPositionUpdateEvent) - return false; -#undef DO_ -} - -void PlayerPositionUpdateEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.PlayerPositionUpdateEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawn_id(), output); - } - - // int32 delta_heading = 2; - if (this->delta_heading() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->delta_heading(), output); - } - - // int32 x_pos = 3; - if (this->x_pos() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->x_pos(), output); - } - - // int32 padding0002 = 4; - if (this->padding0002() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->padding0002(), output); - } - - // int32 y_pos = 5; - if (this->y_pos() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(5, this->y_pos(), output); - } - - // int32 animation = 6; - if (this->animation() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(6, this->animation(), output); - } - - // int32 padding0006 = 7; - if (this->padding0006() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(7, this->padding0006(), output); - } - - // int32 z_pos = 8; - if (this->z_pos() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(8, this->z_pos(), output); - } - - // int32 delta_y = 9; - if (this->delta_y() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(9, this->delta_y(), output); - } - - // int32 delta_x = 10; - if (this->delta_x() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(10, this->delta_x(), output); - } - - // int32 heading = 11; - if (this->heading() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(11, this->heading(), output); - } - - // int32 padding0014 = 12; - if (this->padding0014() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(12, this->padding0014(), output); - } - - // int32 delta_z = 13; - if (this->delta_z() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(13, this->delta_z(), output); - } - - // int32 padding0018 = 14; - if (this->padding0018() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(14, this->padding0018(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.PlayerPositionUpdateEvent) -} - -::google::protobuf::uint8* PlayerPositionUpdateEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.PlayerPositionUpdateEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawn_id(), target); - } - - // int32 delta_heading = 2; - if (this->delta_heading() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(2, this->delta_heading(), target); - } - - // int32 x_pos = 3; - if (this->x_pos() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(3, this->x_pos(), target); - } - - // int32 padding0002 = 4; - if (this->padding0002() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->padding0002(), target); - } - - // int32 y_pos = 5; - if (this->y_pos() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(5, this->y_pos(), target); - } - - // int32 animation = 6; - if (this->animation() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(6, this->animation(), target); - } - - // int32 padding0006 = 7; - if (this->padding0006() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(7, this->padding0006(), target); - } - - // int32 z_pos = 8; - if (this->z_pos() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(8, this->z_pos(), target); - } - - // int32 delta_y = 9; - if (this->delta_y() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(9, this->delta_y(), target); - } - - // int32 delta_x = 10; - if (this->delta_x() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(10, this->delta_x(), target); - } - - // int32 heading = 11; - if (this->heading() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(11, this->heading(), target); - } - - // int32 padding0014 = 12; - if (this->padding0014() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(12, this->padding0014(), target); - } - - // int32 delta_z = 13; - if (this->delta_z() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(13, this->delta_z(), target); - } - - // int32 padding0018 = 14; - if (this->padding0018() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(14, this->padding0018(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.PlayerPositionUpdateEvent) - return target; -} - -size_t PlayerPositionUpdateEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.PlayerPositionUpdateEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 spawn_id = 1; - if (this->spawn_id() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawn_id()); - } - - // int32 delta_heading = 2; - if (this->delta_heading() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->delta_heading()); - } - - // int32 x_pos = 3; - if (this->x_pos() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->x_pos()); - } - - // int32 padding0002 = 4; - if (this->padding0002() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0002()); - } - - // int32 y_pos = 5; - if (this->y_pos() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->y_pos()); - } - - // int32 animation = 6; - if (this->animation() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->animation()); - } - - // int32 padding0006 = 7; - if (this->padding0006() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0006()); - } - - // int32 z_pos = 8; - if (this->z_pos() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->z_pos()); - } - - // int32 delta_y = 9; - if (this->delta_y() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->delta_y()); - } - - // int32 delta_x = 10; - if (this->delta_x() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->delta_x()); - } - - // int32 heading = 11; - if (this->heading() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->heading()); - } - - // int32 padding0014 = 12; - if (this->padding0014() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0014()); - } - - // int32 delta_z = 13; - if (this->delta_z() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->delta_z()); - } - - // int32 padding0018 = 14; - if (this->padding0018() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0018()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void PlayerPositionUpdateEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.PlayerPositionUpdateEvent) - GOOGLE_DCHECK_NE(&from, this); - const PlayerPositionUpdateEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.PlayerPositionUpdateEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.PlayerPositionUpdateEvent) - MergeFrom(*source); - } -} - -void PlayerPositionUpdateEvent::MergeFrom(const PlayerPositionUpdateEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.PlayerPositionUpdateEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.spawn_id() != 0) { - set_spawn_id(from.spawn_id()); - } - if (from.delta_heading() != 0) { - set_delta_heading(from.delta_heading()); - } - if (from.x_pos() != 0) { - set_x_pos(from.x_pos()); - } - if (from.padding0002() != 0) { - set_padding0002(from.padding0002()); - } - if (from.y_pos() != 0) { - set_y_pos(from.y_pos()); - } - if (from.animation() != 0) { - set_animation(from.animation()); - } - if (from.padding0006() != 0) { - set_padding0006(from.padding0006()); - } - if (from.z_pos() != 0) { - set_z_pos(from.z_pos()); - } - if (from.delta_y() != 0) { - set_delta_y(from.delta_y()); - } - if (from.delta_x() != 0) { - set_delta_x(from.delta_x()); - } - if (from.heading() != 0) { - set_heading(from.heading()); - } - if (from.padding0014() != 0) { - set_padding0014(from.padding0014()); - } - if (from.delta_z() != 0) { - set_delta_z(from.delta_z()); - } - if (from.padding0018() != 0) { - set_padding0018(from.padding0018()); - } -} - -void PlayerPositionUpdateEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.PlayerPositionUpdateEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void PlayerPositionUpdateEvent::CopyFrom(const PlayerPositionUpdateEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.PlayerPositionUpdateEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool PlayerPositionUpdateEvent::IsInitialized() const { - return true; -} - -void PlayerPositionUpdateEvent::Swap(PlayerPositionUpdateEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void PlayerPositionUpdateEvent::InternalSwap(PlayerPositionUpdateEvent* other) { - using std::swap; - swap(spawn_id_, other->spawn_id_); - swap(delta_heading_, other->delta_heading_); - swap(x_pos_, other->x_pos_); - swap(padding0002_, other->padding0002_); - swap(y_pos_, other->y_pos_); - swap(animation_, other->animation_); - swap(padding0006_, other->padding0006_); - swap(z_pos_, other->z_pos_); - swap(delta_y_, other->delta_y_); - swap(delta_x_, other->delta_x_); - swap(heading_, other->heading_); - swap(padding0014_, other->padding0014_); - swap(delta_z_, other->delta_z_); - swap(padding0018_, other->padding0018_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata PlayerPositionUpdateEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void AnimationEvent::InitAsDefaultInstance() { -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int AnimationEvent::kSpawnidFieldNumber; -const int AnimationEvent::kSpeedFieldNumber; -const int AnimationEvent::kActionFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -AnimationEvent::AnimationEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsAnimationEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.AnimationEvent) -} -AnimationEvent::AnimationEvent(const AnimationEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::memcpy(&spawnid_, &from.spawnid_, - static_cast(reinterpret_cast(&action_) - - reinterpret_cast(&spawnid_)) + sizeof(action_)); - // @@protoc_insertion_point(copy_constructor:eqproto.AnimationEvent) -} - -void AnimationEvent::SharedCtor() { - ::memset(&spawnid_, 0, static_cast( - reinterpret_cast(&action_) - - reinterpret_cast(&spawnid_)) + sizeof(action_)); - _cached_size_ = 0; -} - -AnimationEvent::~AnimationEvent() { - // @@protoc_insertion_point(destructor:eqproto.AnimationEvent) - SharedDtor(); -} - -void AnimationEvent::SharedDtor() { -} - -void AnimationEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* AnimationEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const AnimationEvent& AnimationEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsAnimationEvent(); - return *internal_default_instance(); -} - -AnimationEvent* AnimationEvent::New(::google::protobuf::Arena* arena) const { - AnimationEvent* n = new AnimationEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void AnimationEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.AnimationEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - ::memset(&spawnid_, 0, static_cast( - reinterpret_cast(&action_) - - reinterpret_cast(&spawnid_)) + sizeof(action_)); - _internal_metadata_.Clear(); -} - -bool AnimationEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.AnimationEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(127u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 spawnid = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawnid_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 speed = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &speed_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 action = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &action_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.AnimationEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.AnimationEvent) - return false; -#undef DO_ -} - -void AnimationEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.AnimationEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawnid = 1; - if (this->spawnid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->spawnid(), output); - } - - // uint32 speed = 2; - if (this->speed() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->speed(), output); - } - - // uint32 action = 3; - if (this->action() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->action(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.AnimationEvent) -} - -::google::protobuf::uint8* AnimationEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.AnimationEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 spawnid = 1; - if (this->spawnid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->spawnid(), target); - } - - // uint32 speed = 2; - if (this->speed() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->speed(), target); - } - - // uint32 action = 3; - if (this->action() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->action(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.AnimationEvent) - return target; -} - -size_t AnimationEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.AnimationEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // uint32 spawnid = 1; - if (this->spawnid() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawnid()); - } - - // uint32 speed = 2; - if (this->speed() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->speed()); - } - - // uint32 action = 3; - if (this->action() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->action()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void AnimationEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.AnimationEvent) - GOOGLE_DCHECK_NE(&from, this); - const AnimationEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.AnimationEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.AnimationEvent) - MergeFrom(*source); - } -} - -void AnimationEvent::MergeFrom(const AnimationEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.AnimationEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.spawnid() != 0) { - set_spawnid(from.spawnid()); - } - if (from.speed() != 0) { - set_speed(from.speed()); - } - if (from.action() != 0) { - set_action(from.action()); - } -} - -void AnimationEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.AnimationEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void AnimationEvent::CopyFrom(const AnimationEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.AnimationEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool AnimationEvent::IsInitialized() const { - return true; -} - -void AnimationEvent::Swap(AnimationEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void AnimationEvent::InternalSwap(AnimationEvent* other) { - using std::swap; - swap(spawnid_, other->spawnid_); - swap(speed_, other->speed_); - swap(action_, other->action_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata AnimationEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// =================================================================== - -void SpawnEvent::InitAsDefaultInstance() { - ::eqproto::_SpawnEvent_default_instance_._instance.get_mutable()->equipment_ = const_cast< ::eqproto::TextureProfile*>( - ::eqproto::TextureProfile::internal_default_instance()); - ::eqproto::_SpawnEvent_default_instance_._instance.get_mutable()->equipment_tint_ = const_cast< ::eqproto::TintProfile*>( - ::eqproto::TintProfile::internal_default_instance()); -} -#if !defined(_MSC_VER) || _MSC_VER >= 1900 -const int SpawnEvent::kUnknown0000FieldNumber; -const int SpawnEvent::kGmFieldNumber; -const int SpawnEvent::kUnknown0003FieldNumber; -const int SpawnEvent::kAaitleFieldNumber; -const int SpawnEvent::kUnknown0004FieldNumber; -const int SpawnEvent::kAnonFieldNumber; -const int SpawnEvent::kFaceFieldNumber; -const int SpawnEvent::kNameFieldNumber; -const int SpawnEvent::kDeityFieldNumber; -const int SpawnEvent::kUnknown0073FieldNumber; -const int SpawnEvent::kSizeFieldNumber; -const int SpawnEvent::kUnknown0079FieldNumber; -const int SpawnEvent::kNPCFieldNumber; -const int SpawnEvent::kInvisFieldNumber; -const int SpawnEvent::kHaircolorFieldNumber; -const int SpawnEvent::kCurHpFieldNumber; -const int SpawnEvent::kMaxHpFieldNumber; -const int SpawnEvent::kFindableFieldNumber; -const int SpawnEvent::kUnknown0089FieldNumber; -const int SpawnEvent::kDeltaHeadingFieldNumber; -const int SpawnEvent::kXFieldNumber; -const int SpawnEvent::kPadding0054FieldNumber; -const int SpawnEvent::kYFieldNumber; -const int SpawnEvent::kAnimationFieldNumber; -const int SpawnEvent::kPadding0058FieldNumber; -const int SpawnEvent::kZFieldNumber; -const int SpawnEvent::kDeltaYFieldNumber; -const int SpawnEvent::kDeltaXFieldNumber; -const int SpawnEvent::kHeadingFieldNumber; -const int SpawnEvent::kPadding0066FieldNumber; -const int SpawnEvent::kDeltaZFieldNumber; -const int SpawnEvent::kPadding0070FieldNumber; -const int SpawnEvent::kEyecolor1FieldNumber; -const int SpawnEvent::kUnknown0115FieldNumber; -const int SpawnEvent::kStandStateFieldNumber; -const int SpawnEvent::kDrakkinHeritageFieldNumber; -const int SpawnEvent::kDrakkinTattooFieldNumber; -const int SpawnEvent::kDrakkinDetailsFieldNumber; -const int SpawnEvent::kShowhelmFieldNumber; -const int SpawnEvent::kUnknown0140FieldNumber; -const int SpawnEvent::kIsNpcFieldNumber; -const int SpawnEvent::kHairstyleFieldNumber; -const int SpawnEvent::kBeardFieldNumber; -const int SpawnEvent::kUnknown0147FieldNumber; -const int SpawnEvent::kLevelFieldNumber; -const int SpawnEvent::kPlayerStateFieldNumber; -const int SpawnEvent::kBeardcolorFieldNumber; -const int SpawnEvent::kSuffixFieldNumber; -const int SpawnEvent::kPetOwnerIdFieldNumber; -const int SpawnEvent::kGuildrankFieldNumber; -const int SpawnEvent::kUnknown0194FieldNumber; -const int SpawnEvent::kEquipmentFieldNumber; -const int SpawnEvent::kRunspeedFieldNumber; -const int SpawnEvent::kAfkFieldNumber; -const int SpawnEvent::kGuildIDFieldNumber; -const int SpawnEvent::kTitleFieldNumber; -const int SpawnEvent::kUnknown0274FieldNumber; -const int SpawnEvent::kSetTo0XFFFieldNumber; -const int SpawnEvent::kHelmFieldNumber; -const int SpawnEvent::kRaceFieldNumber; -const int SpawnEvent::kUnknown0288FieldNumber; -const int SpawnEvent::kLastNameFieldNumber; -const int SpawnEvent::kWalkspeedFieldNumber; -const int SpawnEvent::kUnknown0328FieldNumber; -const int SpawnEvent::kIsPetFieldNumber; -const int SpawnEvent::kLightFieldNumber; -const int SpawnEvent::kClassFieldNumber; -const int SpawnEvent::kEyecolor2FieldNumber; -const int SpawnEvent::kFlymodeFieldNumber; -const int SpawnEvent::kGenderFieldNumber; -const int SpawnEvent::kBodytypeFieldNumber; -const int SpawnEvent::kUnknown0336FieldNumber; -const int SpawnEvent::kEquipChest2FieldNumber; -const int SpawnEvent::kMountColorFieldNumber; -const int SpawnEvent::kSpawnIdFieldNumber; -const int SpawnEvent::kUnknown0344FieldNumber; -const int SpawnEvent::kIsMercenaryFieldNumber; -const int SpawnEvent::kEquipmentTintFieldNumber; -const int SpawnEvent::kLfgFieldNumber; -const int SpawnEvent::kDestructibleObjectFieldNumber; -const int SpawnEvent::kDestructibleModelFieldNumber; -const int SpawnEvent::kDestructibleName2FieldNumber; -const int SpawnEvent::kDestructibleStringFieldNumber; -const int SpawnEvent::kDestructibleAppearanceFieldNumber; -const int SpawnEvent::kDestructibleUnk1FieldNumber; -const int SpawnEvent::kDestructibleID1FieldNumber; -const int SpawnEvent::kDestructibleID2FieldNumber; -const int SpawnEvent::kDestructibleID3FieldNumber; -const int SpawnEvent::kDestructibleID4FieldNumber; -const int SpawnEvent::kDestructibleUnk2FieldNumber; -const int SpawnEvent::kDestructibleUnk3FieldNumber; -const int SpawnEvent::kDestructibleUnk4FieldNumber; -const int SpawnEvent::kDestructibleUnk5FieldNumber; -const int SpawnEvent::kDestructibleUnk6FieldNumber; -const int SpawnEvent::kDestructibleUnk7FieldNumber; -const int SpawnEvent::kDestructibleUnk8FieldNumber; -const int SpawnEvent::kDestructibleUnk9FieldNumber; -const int SpawnEvent::kTargetableWithHotkeyFieldNumber; -const int SpawnEvent::kShowNameFieldNumber; -#endif // !defined(_MSC_VER) || _MSC_VER >= 1900 - -SpawnEvent::SpawnEvent() - : ::google::protobuf::Message(), _internal_metadata_(NULL) { - if (GOOGLE_PREDICT_TRUE(this != internal_default_instance())) { - ::protobuf_message_2eproto::InitDefaultsSpawnEvent(); - } - SharedCtor(); - // @@protoc_insertion_point(constructor:eqproto.SpawnEvent) -} -SpawnEvent::SpawnEvent(const SpawnEvent& from) - : ::google::protobuf::Message(), - _internal_metadata_(NULL), - _cached_size_(0) { - _internal_metadata_.MergeFrom(from._internal_metadata_); - name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.name().size() > 0) { - name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); - } - suffix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.suffix().size() > 0) { - suffix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.suffix_); - } - title_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.title().size() > 0) { - title_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.title_); - } - lastname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.lastname().size() > 0) { - lastname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.lastname_); - } - destructiblemodel_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.destructiblemodel().size() > 0) { - destructiblemodel_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblemodel_); - } - destructiblename2_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.destructiblename2().size() > 0) { - destructiblename2_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblename2_); - } - destructiblestring_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (from.destructiblestring().size() > 0) { - destructiblestring_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblestring_); - } - if (from.has_equipment()) { - equipment_ = new ::eqproto::TextureProfile(*from.equipment_); - } else { - equipment_ = NULL; - } - if (from.has_equipment_tint()) { - equipment_tint_ = new ::eqproto::TintProfile(*from.equipment_tint_); - } else { - equipment_tint_ = NULL; - } - ::memcpy(&unknown0000_, &from.unknown0000_, - static_cast(reinterpret_cast(&destructibleunk9_) - - reinterpret_cast(&unknown0000_)) + sizeof(destructibleunk9_)); - // @@protoc_insertion_point(copy_constructor:eqproto.SpawnEvent) -} - -void SpawnEvent::SharedCtor() { - name_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - suffix_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - title_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - lastname_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblemodel_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblename2_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblestring_.UnsafeSetDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - ::memset(&equipment_, 0, static_cast( - reinterpret_cast(&destructibleunk9_) - - reinterpret_cast(&equipment_)) + sizeof(destructibleunk9_)); - _cached_size_ = 0; -} - -SpawnEvent::~SpawnEvent() { - // @@protoc_insertion_point(destructor:eqproto.SpawnEvent) - SharedDtor(); -} - -void SpawnEvent::SharedDtor() { - name_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - suffix_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - title_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - lastname_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblemodel_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblename2_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblestring_.DestroyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (this != internal_default_instance()) delete equipment_; - if (this != internal_default_instance()) delete equipment_tint_; -} - -void SpawnEvent::SetCachedSize(int size) const { - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); -} -const ::google::protobuf::Descriptor* SpawnEvent::descriptor() { - ::protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages].descriptor; -} - -const SpawnEvent& SpawnEvent::default_instance() { - ::protobuf_message_2eproto::InitDefaultsSpawnEvent(); - return *internal_default_instance(); -} - -SpawnEvent* SpawnEvent::New(::google::protobuf::Arena* arena) const { - SpawnEvent* n = new SpawnEvent; - if (arena != NULL) { - arena->Own(n); - } - return n; -} - -void SpawnEvent::Clear() { -// @@protoc_insertion_point(message_clear_start:eqproto.SpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - // Prevent compiler warnings about cached_has_bits being unused - (void) cached_has_bits; - - name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - suffix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - title_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - lastname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblemodel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblename2_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - destructiblestring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); - if (GetArenaNoVirtual() == NULL && equipment_ != NULL) { - delete equipment_; - } - equipment_ = NULL; - if (GetArenaNoVirtual() == NULL && equipment_tint_ != NULL) { - delete equipment_tint_; - } - equipment_tint_ = NULL; - ::memset(&unknown0000_, 0, static_cast( - reinterpret_cast(&destructibleunk9_) - - reinterpret_cast(&unknown0000_)) + sizeof(destructibleunk9_)); - _internal_metadata_.Clear(); -} - -bool SpawnEvent::MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) { -#define DO_(EXPRESSION) if (!GOOGLE_PREDICT_TRUE(EXPRESSION)) goto failure - ::google::protobuf::uint32 tag; - // @@protoc_insertion_point(parse_start:eqproto.SpawnEvent) - for (;;) { - ::std::pair< ::google::protobuf::uint32, bool> p = input->ReadTagWithCutoffNoLastTag(16383u); - tag = p.first; - if (!p.second) goto handle_unusual; - switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { - // uint32 unknown0000 = 1; - case 1: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 8 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0000_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 gm = 2; - case 2: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 16 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &gm_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0003 = 3; - case 3: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 24 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0003_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 aaitle = 4; - case 4: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 32 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &aaitle_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0004 = 5; - case 5: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 40 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0004_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 anon = 6; - case 6: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 48 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &anon_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 face = 7; - case 7: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 56 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &face_))); - } else { - goto handle_unusual; - } - break; - } - - // string name = 8; - case 8: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(66u /* 66 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_name())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.name")); - } else { - goto handle_unusual; - } - break; - } - - // uint32 deity = 9; - case 9: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(72u /* 72 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &deity_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0073 = 10; - case 10: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(80u /* 80 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0073_))); - } else { - goto handle_unusual; - } - break; - } - - // float size = 11; - case 11: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(93u /* 93 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &size_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0079 = 12; - case 12: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(96u /* 96 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0079_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 NPC = 13; - case 13: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(104u /* 104 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &npc_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 invis = 14; - case 14: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(112u /* 112 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &invis_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 haircolor = 15; - case 15: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(120u /* 120 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &haircolor_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 curHp = 16; - case 16: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(128u /* 128 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &curhp_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 max_hp = 17; - case 17: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(136u /* 136 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &max_hp_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 findable = 18; - case 18: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(144u /* 144 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &findable_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0089 = 19; - case 19: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(152u /* 152 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0089_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 deltaHeading = 20; - case 20: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(160u /* 160 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &deltaheading_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 x = 21; - case 21: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(168u /* 168 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &x_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0054 = 22; - case 22: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(176u /* 176 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0054_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 y = 23; - case 23: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(184u /* 184 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &y_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 animation = 24; - case 24: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(192u /* 192 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &animation_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0058 = 25; - case 25: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(200u /* 200 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0058_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 z = 26; - case 26: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(208u /* 208 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &z_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 deltaY = 27; - case 27: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(216u /* 216 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &deltay_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 deltaX = 28; - case 28: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(224u /* 224 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &deltax_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 heading = 29; - case 29: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(232u /* 232 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &heading_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0066 = 30; - case 30: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(240u /* 240 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0066_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 deltaZ = 31; - case 31: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(248u /* 248 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &deltaz_))); - } else { - goto handle_unusual; - } - break; - } - - // int32 padding0070 = 32; - case 32: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(0u /* 256 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( - input, &padding0070_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 eyecolor1 = 33; - case 33: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 264 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &eyecolor1_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0115 = 34; - case 34: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 272 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0115_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 StandState = 35; - case 35: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 280 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &standstate_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 drakkin_heritage = 36; - case 36: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 288 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &drakkin_heritage_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 drakkin_tattoo = 37; - case 37: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 296 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &drakkin_tattoo_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 drakkin_details = 38; - case 38: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 304 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &drakkin_details_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 showhelm = 39; - case 39: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 312 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &showhelm_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0140 = 40; - case 40: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 320 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0140_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 is_npc = 41; - case 41: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(72u /* 328 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &is_npc_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 hairstyle = 42; - case 42: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(80u /* 336 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &hairstyle_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 beard = 43; - case 43: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(88u /* 344 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &beard_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0147 = 44; - case 44: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(96u /* 352 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0147_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 level = 45; - case 45: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(104u /* 360 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &level_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 PlayerState = 46; - case 46: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(112u /* 368 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &playerstate_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 beardcolor = 47; - case 47: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(120u /* 376 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &beardcolor_))); - } else { - goto handle_unusual; - } - break; - } - - // string suffix = 48; - case 48: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(130u /* 386 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_suffix())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->suffix().data(), static_cast(this->suffix().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.suffix")); - } else { - goto handle_unusual; - } - break; - } - - // uint32 petOwnerId = 49; - case 49: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(136u /* 392 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &petownerid_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 guildrank = 50; - case 50: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(144u /* 400 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &guildrank_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0194 = 51; - case 51: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(152u /* 408 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0194_))); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.TextureProfile equipment = 52; - case 52: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(162u /* 418 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_equipment())); - } else { - goto handle_unusual; - } - break; - } - - // float runspeed = 53; - case 53: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(173u /* 429 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &runspeed_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 afk = 54; - case 54: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(176u /* 432 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &afk_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 guildID = 55; - case 55: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(184u /* 440 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &guildid_))); - } else { - goto handle_unusual; - } - break; - } - - // string title = 56; - case 56: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(194u /* 450 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_title())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->title().data(), static_cast(this->title().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.title")); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0274 = 57; - case 57: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(200u /* 456 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0274_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 set_to_0xFF = 58; - case 58: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(208u /* 464 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &set_to_0xff_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 helm = 59; - case 59: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(216u /* 472 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &helm_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 race = 60; - case 60: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(224u /* 480 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &race_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0288 = 61; - case 61: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(232u /* 488 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0288_))); - } else { - goto handle_unusual; - } - break; - } - - // string lastName = 62; - case 62: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(242u /* 498 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_lastname())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->lastname().data(), static_cast(this->lastname().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.lastName")); - } else { - goto handle_unusual; - } - break; - } - - // float walkspeed = 63; - case 63: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(253u /* 509 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - float, ::google::protobuf::internal::WireFormatLite::TYPE_FLOAT>( - input, &walkspeed_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0328 = 64; - case 64: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(0u /* 512 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0328_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 is_pet = 65; - case 65: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 520 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &is_pet_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 light = 66; - case 66: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 528 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &light_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 class_ = 67; - case 67: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 536 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &class__))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 eyecolor2 = 68; - case 68: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 544 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &eyecolor2_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 flymode = 69; - case 69: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(40u /* 552 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &flymode_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 gender = 70; - case 70: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(48u /* 560 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &gender_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 bodytype = 71; - case 71: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(56u /* 568 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &bodytype_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0336 = 72; - case 72: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(64u /* 576 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0336_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 equip_chest2 = 73; - case 73: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(72u /* 584 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &equip_chest2_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 mount_color = 74; - case 74: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(80u /* 592 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &mount_color_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 spawnId = 75; - case 75: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(88u /* 600 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &spawnid_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 unknown0344 = 76; - case 76: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(96u /* 608 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &unknown0344_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 IsMercenary = 77; - case 77: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(104u /* 616 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &ismercenary_))); - } else { - goto handle_unusual; - } - break; - } - - // .eqproto.TintProfile equipment_tint = 78; - case 78: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(114u /* 626 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadMessage( - input, mutable_equipment_tint())); - } else { - goto handle_unusual; - } - break; - } - - // uint32 lfg = 79; - case 79: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(120u /* 632 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &lfg_))); - } else { - goto handle_unusual; - } - break; - } - - // bool DestructibleObject = 80; - case 80: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(128u /* 640 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( - input, &destructibleobject_))); - } else { - goto handle_unusual; - } - break; - } - - // string DestructibleModel = 82; - case 82: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(146u /* 658 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_destructiblemodel())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblemodel().data(), static_cast(this->destructiblemodel().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.DestructibleModel")); - } else { - goto handle_unusual; - } - break; - } - - // string DestructibleName2 = 83; - case 83: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(154u /* 666 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_destructiblename2())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblename2().data(), static_cast(this->destructiblename2().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.DestructibleName2")); - } else { - goto handle_unusual; - } - break; - } - - // string DestructibleString = 84; - case 84: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(162u /* 674 & 0xFF */)) { - DO_(::google::protobuf::internal::WireFormatLite::ReadString( - input, this->mutable_destructiblestring())); - DO_(::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblestring().data(), static_cast(this->destructiblestring().length()), - ::google::protobuf::internal::WireFormatLite::PARSE, - "eqproto.SpawnEvent.DestructibleString")); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleAppearance = 85; - case 85: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(168u /* 680 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleappearance_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk1 = 86; - case 86: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(176u /* 688 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk1_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleID1 = 87; - case 87: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(184u /* 696 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleid1_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleID2 = 88; - case 88: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(192u /* 704 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleid2_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleID3 = 89; - case 89: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(200u /* 712 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleid3_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleID4 = 90; - case 90: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(208u /* 720 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleid4_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk2 = 91; - case 91: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(216u /* 728 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk2_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk3 = 92; - case 92: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(224u /* 736 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk3_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk4 = 93; - case 93: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(232u /* 744 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk4_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk5 = 94; - case 94: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(240u /* 752 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk5_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk6 = 95; - case 95: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(248u /* 760 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk6_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk7 = 96; - case 96: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(0u /* 768 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk7_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk8 = 97; - case 97: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(8u /* 776 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk8_))); - } else { - goto handle_unusual; - } - break; - } - - // uint32 DestructibleUnk9 = 98; - case 98: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(16u /* 784 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>( - input, &destructibleunk9_))); - } else { - goto handle_unusual; - } - break; - } - - // bool targetable_with_hotkey = 99; - case 99: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(24u /* 792 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( - input, &targetable_with_hotkey_))); - } else { - goto handle_unusual; - } - break; - } - - // bool show_name = 100; - case 100: { - if (static_cast< ::google::protobuf::uint8>(tag) == - static_cast< ::google::protobuf::uint8>(32u /* 800 & 0xFF */)) { - - DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< - bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>( - input, &show_name_))); - } else { - goto handle_unusual; - } - break; - } - - default: { - handle_unusual: - if (tag == 0) { - goto success; - } - DO_(::google::protobuf::internal::WireFormat::SkipField( - input, tag, _internal_metadata_.mutable_unknown_fields())); - break; - } - } - } -success: - // @@protoc_insertion_point(parse_success:eqproto.SpawnEvent) - return true; -failure: - // @@protoc_insertion_point(parse_failure:eqproto.SpawnEvent) - return false; -#undef DO_ -} - -void SpawnEvent::SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const { - // @@protoc_insertion_point(serialize_start:eqproto.SpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 unknown0000 = 1; - if (this->unknown0000() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->unknown0000(), output); - } - - // uint32 gm = 2; - if (this->gm() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->gm(), output); - } - - // uint32 unknown0003 = 3; - if (this->unknown0003() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->unknown0003(), output); - } - - // uint32 aaitle = 4; - if (this->aaitle() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->aaitle(), output); - } - - // uint32 unknown0004 = 5; - if (this->unknown0004() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(5, this->unknown0004(), output); - } - - // uint32 anon = 6; - if (this->anon() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(6, this->anon(), output); - } - - // uint32 face = 7; - if (this->face() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(7, this->face(), output); - } - - // string name = 8; - if (this->name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.name"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 8, this->name(), output); - } - - // uint32 deity = 9; - if (this->deity() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(9, this->deity(), output); - } - - // uint32 unknown0073 = 10; - if (this->unknown0073() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(10, this->unknown0073(), output); - } - - // float size = 11; - if (this->size() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(11, this->size(), output); - } - - // uint32 unknown0079 = 12; - if (this->unknown0079() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(12, this->unknown0079(), output); - } - - // uint32 NPC = 13; - if (this->npc() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(13, this->npc(), output); - } - - // uint32 invis = 14; - if (this->invis() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(14, this->invis(), output); - } - - // uint32 haircolor = 15; - if (this->haircolor() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(15, this->haircolor(), output); - } - - // uint32 curHp = 16; - if (this->curhp() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(16, this->curhp(), output); - } - - // uint32 max_hp = 17; - if (this->max_hp() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(17, this->max_hp(), output); - } - - // uint32 findable = 18; - if (this->findable() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(18, this->findable(), output); - } - - // uint32 unknown0089 = 19; - if (this->unknown0089() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(19, this->unknown0089(), output); - } - - // int32 deltaHeading = 20; - if (this->deltaheading() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(20, this->deltaheading(), output); - } - - // int32 x = 21; - if (this->x() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(21, this->x(), output); - } - - // int32 padding0054 = 22; - if (this->padding0054() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(22, this->padding0054(), output); - } - - // int32 y = 23; - if (this->y() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(23, this->y(), output); - } - - // int32 animation = 24; - if (this->animation() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(24, this->animation(), output); - } - - // int32 padding0058 = 25; - if (this->padding0058() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(25, this->padding0058(), output); - } - - // int32 z = 26; - if (this->z() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(26, this->z(), output); - } - - // int32 deltaY = 27; - if (this->deltay() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(27, this->deltay(), output); - } - - // int32 deltaX = 28; - if (this->deltax() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(28, this->deltax(), output); - } - - // uint32 heading = 29; - if (this->heading() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(29, this->heading(), output); - } - - // int32 padding0066 = 30; - if (this->padding0066() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(30, this->padding0066(), output); - } - - // int32 deltaZ = 31; - if (this->deltaz() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(31, this->deltaz(), output); - } - - // int32 padding0070 = 32; - if (this->padding0070() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteInt32(32, this->padding0070(), output); - } - - // uint32 eyecolor1 = 33; - if (this->eyecolor1() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(33, this->eyecolor1(), output); - } - - // uint32 unknown0115 = 34; - if (this->unknown0115() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(34, this->unknown0115(), output); - } - - // uint32 StandState = 35; - if (this->standstate() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(35, this->standstate(), output); - } - - // uint32 drakkin_heritage = 36; - if (this->drakkin_heritage() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(36, this->drakkin_heritage(), output); - } - - // uint32 drakkin_tattoo = 37; - if (this->drakkin_tattoo() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(37, this->drakkin_tattoo(), output); - } - - // uint32 drakkin_details = 38; - if (this->drakkin_details() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(38, this->drakkin_details(), output); - } - - // uint32 showhelm = 39; - if (this->showhelm() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(39, this->showhelm(), output); - } - - // uint32 unknown0140 = 40; - if (this->unknown0140() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(40, this->unknown0140(), output); - } - - // uint32 is_npc = 41; - if (this->is_npc() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(41, this->is_npc(), output); - } - - // uint32 hairstyle = 42; - if (this->hairstyle() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(42, this->hairstyle(), output); - } - - // uint32 beard = 43; - if (this->beard() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(43, this->beard(), output); - } - - // uint32 unknown0147 = 44; - if (this->unknown0147() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(44, this->unknown0147(), output); - } - - // uint32 level = 45; - if (this->level() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(45, this->level(), output); - } - - // uint32 PlayerState = 46; - if (this->playerstate() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(46, this->playerstate(), output); - } - - // uint32 beardcolor = 47; - if (this->beardcolor() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(47, this->beardcolor(), output); - } - - // string suffix = 48; - if (this->suffix().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->suffix().data(), static_cast(this->suffix().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.suffix"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 48, this->suffix(), output); - } - - // uint32 petOwnerId = 49; - if (this->petownerid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(49, this->petownerid(), output); - } - - // uint32 guildrank = 50; - if (this->guildrank() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(50, this->guildrank(), output); - } - - // uint32 unknown0194 = 51; - if (this->unknown0194() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(51, this->unknown0194(), output); - } - - // .eqproto.TextureProfile equipment = 52; - if (this->has_equipment()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 52, *this->equipment_, output); - } - - // float runspeed = 53; - if (this->runspeed() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(53, this->runspeed(), output); - } - - // uint32 afk = 54; - if (this->afk() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(54, this->afk(), output); - } - - // uint32 guildID = 55; - if (this->guildid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(55, this->guildid(), output); - } - - // string title = 56; - if (this->title().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->title().data(), static_cast(this->title().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.title"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 56, this->title(), output); - } - - // uint32 unknown0274 = 57; - if (this->unknown0274() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(57, this->unknown0274(), output); - } - - // uint32 set_to_0xFF = 58; - if (this->set_to_0xff() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(58, this->set_to_0xff(), output); - } - - // uint32 helm = 59; - if (this->helm() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(59, this->helm(), output); - } - - // uint32 race = 60; - if (this->race() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(60, this->race(), output); - } - - // uint32 unknown0288 = 61; - if (this->unknown0288() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(61, this->unknown0288(), output); - } - - // string lastName = 62; - if (this->lastname().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->lastname().data(), static_cast(this->lastname().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.lastName"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 62, this->lastname(), output); - } - - // float walkspeed = 63; - if (this->walkspeed() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteFloat(63, this->walkspeed(), output); - } - - // uint32 unknown0328 = 64; - if (this->unknown0328() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(64, this->unknown0328(), output); - } - - // uint32 is_pet = 65; - if (this->is_pet() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(65, this->is_pet(), output); - } - - // uint32 light = 66; - if (this->light() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(66, this->light(), output); - } - - // uint32 class_ = 67; - if (this->class_() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(67, this->class_(), output); - } - - // uint32 eyecolor2 = 68; - if (this->eyecolor2() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(68, this->eyecolor2(), output); - } - - // uint32 flymode = 69; - if (this->flymode() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(69, this->flymode(), output); - } - - // uint32 gender = 70; - if (this->gender() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(70, this->gender(), output); - } - - // uint32 bodytype = 71; - if (this->bodytype() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(71, this->bodytype(), output); - } - - // uint32 unknown0336 = 72; - if (this->unknown0336() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(72, this->unknown0336(), output); - } - - // uint32 equip_chest2 = 73; - if (this->equip_chest2() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(73, this->equip_chest2(), output); - } - - // uint32 mount_color = 74; - if (this->mount_color() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(74, this->mount_color(), output); - } - - // uint32 spawnId = 75; - if (this->spawnid() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(75, this->spawnid(), output); - } - - // uint32 unknown0344 = 76; - if (this->unknown0344() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(76, this->unknown0344(), output); - } - - // uint32 IsMercenary = 77; - if (this->ismercenary() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(77, this->ismercenary(), output); - } - - // .eqproto.TintProfile equipment_tint = 78; - if (this->has_equipment_tint()) { - ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( - 78, *this->equipment_tint_, output); - } - - // uint32 lfg = 79; - if (this->lfg() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(79, this->lfg(), output); - } - - // bool DestructibleObject = 80; - if (this->destructibleobject() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteBool(80, this->destructibleobject(), output); - } - - // string DestructibleModel = 82; - if (this->destructiblemodel().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblemodel().data(), static_cast(this->destructiblemodel().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleModel"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 82, this->destructiblemodel(), output); - } - - // string DestructibleName2 = 83; - if (this->destructiblename2().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblename2().data(), static_cast(this->destructiblename2().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleName2"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 83, this->destructiblename2(), output); - } - - // string DestructibleString = 84; - if (this->destructiblestring().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblestring().data(), static_cast(this->destructiblestring().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleString"); - ::google::protobuf::internal::WireFormatLite::WriteStringMaybeAliased( - 84, this->destructiblestring(), output); - } - - // uint32 DestructibleAppearance = 85; - if (this->destructibleappearance() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(85, this->destructibleappearance(), output); - } - - // uint32 DestructibleUnk1 = 86; - if (this->destructibleunk1() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(86, this->destructibleunk1(), output); - } - - // uint32 DestructibleID1 = 87; - if (this->destructibleid1() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(87, this->destructibleid1(), output); - } - - // uint32 DestructibleID2 = 88; - if (this->destructibleid2() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(88, this->destructibleid2(), output); - } - - // uint32 DestructibleID3 = 89; - if (this->destructibleid3() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(89, this->destructibleid3(), output); - } - - // uint32 DestructibleID4 = 90; - if (this->destructibleid4() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(90, this->destructibleid4(), output); - } - - // uint32 DestructibleUnk2 = 91; - if (this->destructibleunk2() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(91, this->destructibleunk2(), output); - } - - // uint32 DestructibleUnk3 = 92; - if (this->destructibleunk3() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(92, this->destructibleunk3(), output); - } - - // uint32 DestructibleUnk4 = 93; - if (this->destructibleunk4() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(93, this->destructibleunk4(), output); - } - - // uint32 DestructibleUnk5 = 94; - if (this->destructibleunk5() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(94, this->destructibleunk5(), output); - } - - // uint32 DestructibleUnk6 = 95; - if (this->destructibleunk6() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(95, this->destructibleunk6(), output); - } - - // uint32 DestructibleUnk7 = 96; - if (this->destructibleunk7() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(96, this->destructibleunk7(), output); - } - - // uint32 DestructibleUnk8 = 97; - if (this->destructibleunk8() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(97, this->destructibleunk8(), output); - } - - // uint32 DestructibleUnk9 = 98; - if (this->destructibleunk9() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteUInt32(98, this->destructibleunk9(), output); - } - - // bool targetable_with_hotkey = 99; - if (this->targetable_with_hotkey() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteBool(99, this->targetable_with_hotkey(), output); - } - - // bool show_name = 100; - if (this->show_name() != 0) { - ::google::protobuf::internal::WireFormatLite::WriteBool(100, this->show_name(), output); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - ::google::protobuf::internal::WireFormat::SerializeUnknownFields( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), output); - } - // @@protoc_insertion_point(serialize_end:eqproto.SpawnEvent) -} - -::google::protobuf::uint8* SpawnEvent::InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const { - (void)deterministic; // Unused - // @@protoc_insertion_point(serialize_to_array_start:eqproto.SpawnEvent) - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - // uint32 unknown0000 = 1; - if (this->unknown0000() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->unknown0000(), target); - } - - // uint32 gm = 2; - if (this->gm() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(2, this->gm(), target); - } - - // uint32 unknown0003 = 3; - if (this->unknown0003() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(3, this->unknown0003(), target); - } - - // uint32 aaitle = 4; - if (this->aaitle() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->aaitle(), target); - } - - // uint32 unknown0004 = 5; - if (this->unknown0004() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(5, this->unknown0004(), target); - } - - // uint32 anon = 6; - if (this->anon() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(6, this->anon(), target); - } - - // uint32 face = 7; - if (this->face() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(7, this->face(), target); - } - - // string name = 8; - if (this->name().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->name().data(), static_cast(this->name().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.name"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 8, this->name(), target); - } - - // uint32 deity = 9; - if (this->deity() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(9, this->deity(), target); - } - - // uint32 unknown0073 = 10; - if (this->unknown0073() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(10, this->unknown0073(), target); - } - - // float size = 11; - if (this->size() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(11, this->size(), target); - } - - // uint32 unknown0079 = 12; - if (this->unknown0079() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(12, this->unknown0079(), target); - } - - // uint32 NPC = 13; - if (this->npc() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(13, this->npc(), target); - } - - // uint32 invis = 14; - if (this->invis() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(14, this->invis(), target); - } - - // uint32 haircolor = 15; - if (this->haircolor() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(15, this->haircolor(), target); - } - - // uint32 curHp = 16; - if (this->curhp() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(16, this->curhp(), target); - } - - // uint32 max_hp = 17; - if (this->max_hp() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(17, this->max_hp(), target); - } - - // uint32 findable = 18; - if (this->findable() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(18, this->findable(), target); - } - - // uint32 unknown0089 = 19; - if (this->unknown0089() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(19, this->unknown0089(), target); - } - - // int32 deltaHeading = 20; - if (this->deltaheading() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(20, this->deltaheading(), target); - } - - // int32 x = 21; - if (this->x() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(21, this->x(), target); - } - - // int32 padding0054 = 22; - if (this->padding0054() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(22, this->padding0054(), target); - } - - // int32 y = 23; - if (this->y() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(23, this->y(), target); - } - - // int32 animation = 24; - if (this->animation() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(24, this->animation(), target); - } - - // int32 padding0058 = 25; - if (this->padding0058() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(25, this->padding0058(), target); - } - - // int32 z = 26; - if (this->z() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(26, this->z(), target); - } - - // int32 deltaY = 27; - if (this->deltay() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(27, this->deltay(), target); - } - - // int32 deltaX = 28; - if (this->deltax() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(28, this->deltax(), target); - } - - // uint32 heading = 29; - if (this->heading() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(29, this->heading(), target); - } - - // int32 padding0066 = 30; - if (this->padding0066() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(30, this->padding0066(), target); - } - - // int32 deltaZ = 31; - if (this->deltaz() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(31, this->deltaz(), target); - } - - // int32 padding0070 = 32; - if (this->padding0070() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(32, this->padding0070(), target); - } - - // uint32 eyecolor1 = 33; - if (this->eyecolor1() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(33, this->eyecolor1(), target); - } - - // uint32 unknown0115 = 34; - if (this->unknown0115() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(34, this->unknown0115(), target); - } - - // uint32 StandState = 35; - if (this->standstate() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(35, this->standstate(), target); - } - - // uint32 drakkin_heritage = 36; - if (this->drakkin_heritage() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(36, this->drakkin_heritage(), target); - } - - // uint32 drakkin_tattoo = 37; - if (this->drakkin_tattoo() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(37, this->drakkin_tattoo(), target); - } - - // uint32 drakkin_details = 38; - if (this->drakkin_details() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(38, this->drakkin_details(), target); - } - - // uint32 showhelm = 39; - if (this->showhelm() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(39, this->showhelm(), target); - } - - // uint32 unknown0140 = 40; - if (this->unknown0140() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(40, this->unknown0140(), target); - } - - // uint32 is_npc = 41; - if (this->is_npc() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(41, this->is_npc(), target); - } - - // uint32 hairstyle = 42; - if (this->hairstyle() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(42, this->hairstyle(), target); - } - - // uint32 beard = 43; - if (this->beard() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(43, this->beard(), target); - } - - // uint32 unknown0147 = 44; - if (this->unknown0147() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(44, this->unknown0147(), target); - } - - // uint32 level = 45; - if (this->level() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(45, this->level(), target); - } - - // uint32 PlayerState = 46; - if (this->playerstate() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(46, this->playerstate(), target); - } - - // uint32 beardcolor = 47; - if (this->beardcolor() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(47, this->beardcolor(), target); - } - - // string suffix = 48; - if (this->suffix().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->suffix().data(), static_cast(this->suffix().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.suffix"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 48, this->suffix(), target); - } - - // uint32 petOwnerId = 49; - if (this->petownerid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(49, this->petownerid(), target); - } - - // uint32 guildrank = 50; - if (this->guildrank() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(50, this->guildrank(), target); - } - - // uint32 unknown0194 = 51; - if (this->unknown0194() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(51, this->unknown0194(), target); - } - - // .eqproto.TextureProfile equipment = 52; - if (this->has_equipment()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 52, *this->equipment_, deterministic, target); - } - - // float runspeed = 53; - if (this->runspeed() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(53, this->runspeed(), target); - } - - // uint32 afk = 54; - if (this->afk() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(54, this->afk(), target); - } - - // uint32 guildID = 55; - if (this->guildid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(55, this->guildid(), target); - } - - // string title = 56; - if (this->title().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->title().data(), static_cast(this->title().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.title"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 56, this->title(), target); - } - - // uint32 unknown0274 = 57; - if (this->unknown0274() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(57, this->unknown0274(), target); - } - - // uint32 set_to_0xFF = 58; - if (this->set_to_0xff() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(58, this->set_to_0xff(), target); - } - - // uint32 helm = 59; - if (this->helm() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(59, this->helm(), target); - } - - // uint32 race = 60; - if (this->race() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(60, this->race(), target); - } - - // uint32 unknown0288 = 61; - if (this->unknown0288() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(61, this->unknown0288(), target); - } - - // string lastName = 62; - if (this->lastname().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->lastname().data(), static_cast(this->lastname().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.lastName"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 62, this->lastname(), target); - } - - // float walkspeed = 63; - if (this->walkspeed() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteFloatToArray(63, this->walkspeed(), target); - } - - // uint32 unknown0328 = 64; - if (this->unknown0328() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(64, this->unknown0328(), target); - } - - // uint32 is_pet = 65; - if (this->is_pet() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(65, this->is_pet(), target); - } - - // uint32 light = 66; - if (this->light() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(66, this->light(), target); - } - - // uint32 class_ = 67; - if (this->class_() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(67, this->class_(), target); - } - - // uint32 eyecolor2 = 68; - if (this->eyecolor2() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(68, this->eyecolor2(), target); - } - - // uint32 flymode = 69; - if (this->flymode() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(69, this->flymode(), target); - } - - // uint32 gender = 70; - if (this->gender() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(70, this->gender(), target); - } - - // uint32 bodytype = 71; - if (this->bodytype() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(71, this->bodytype(), target); - } - - // uint32 unknown0336 = 72; - if (this->unknown0336() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(72, this->unknown0336(), target); - } - - // uint32 equip_chest2 = 73; - if (this->equip_chest2() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(73, this->equip_chest2(), target); - } - - // uint32 mount_color = 74; - if (this->mount_color() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(74, this->mount_color(), target); - } - - // uint32 spawnId = 75; - if (this->spawnid() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(75, this->spawnid(), target); - } - - // uint32 unknown0344 = 76; - if (this->unknown0344() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(76, this->unknown0344(), target); - } - - // uint32 IsMercenary = 77; - if (this->ismercenary() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(77, this->ismercenary(), target); - } - - // .eqproto.TintProfile equipment_tint = 78; - if (this->has_equipment_tint()) { - target = ::google::protobuf::internal::WireFormatLite:: - InternalWriteMessageToArray( - 78, *this->equipment_tint_, deterministic, target); - } - - // uint32 lfg = 79; - if (this->lfg() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(79, this->lfg(), target); - } - - // bool DestructibleObject = 80; - if (this->destructibleobject() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(80, this->destructibleobject(), target); - } - - // string DestructibleModel = 82; - if (this->destructiblemodel().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblemodel().data(), static_cast(this->destructiblemodel().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleModel"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 82, this->destructiblemodel(), target); - } - - // string DestructibleName2 = 83; - if (this->destructiblename2().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblename2().data(), static_cast(this->destructiblename2().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleName2"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 83, this->destructiblename2(), target); - } - - // string DestructibleString = 84; - if (this->destructiblestring().size() > 0) { - ::google::protobuf::internal::WireFormatLite::VerifyUtf8String( - this->destructiblestring().data(), static_cast(this->destructiblestring().length()), - ::google::protobuf::internal::WireFormatLite::SERIALIZE, - "eqproto.SpawnEvent.DestructibleString"); - target = - ::google::protobuf::internal::WireFormatLite::WriteStringToArray( - 84, this->destructiblestring(), target); - } - - // uint32 DestructibleAppearance = 85; - if (this->destructibleappearance() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(85, this->destructibleappearance(), target); - } - - // uint32 DestructibleUnk1 = 86; - if (this->destructibleunk1() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(86, this->destructibleunk1(), target); - } - - // uint32 DestructibleID1 = 87; - if (this->destructibleid1() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(87, this->destructibleid1(), target); - } - - // uint32 DestructibleID2 = 88; - if (this->destructibleid2() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(88, this->destructibleid2(), target); - } - - // uint32 DestructibleID3 = 89; - if (this->destructibleid3() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(89, this->destructibleid3(), target); - } - - // uint32 DestructibleID4 = 90; - if (this->destructibleid4() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(90, this->destructibleid4(), target); - } - - // uint32 DestructibleUnk2 = 91; - if (this->destructibleunk2() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(91, this->destructibleunk2(), target); - } - - // uint32 DestructibleUnk3 = 92; - if (this->destructibleunk3() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(92, this->destructibleunk3(), target); - } - - // uint32 DestructibleUnk4 = 93; - if (this->destructibleunk4() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(93, this->destructibleunk4(), target); - } - - // uint32 DestructibleUnk5 = 94; - if (this->destructibleunk5() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(94, this->destructibleunk5(), target); - } - - // uint32 DestructibleUnk6 = 95; - if (this->destructibleunk6() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(95, this->destructibleunk6(), target); - } - - // uint32 DestructibleUnk7 = 96; - if (this->destructibleunk7() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(96, this->destructibleunk7(), target); - } - - // uint32 DestructibleUnk8 = 97; - if (this->destructibleunk8() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(97, this->destructibleunk8(), target); - } - - // uint32 DestructibleUnk9 = 98; - if (this->destructibleunk9() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(98, this->destructibleunk9(), target); - } - - // bool targetable_with_hotkey = 99; - if (this->targetable_with_hotkey() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(99, this->targetable_with_hotkey(), target); - } - - // bool show_name = 100; - if (this->show_name() != 0) { - target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(100, this->show_name(), target); - } - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance()), target); - } - // @@protoc_insertion_point(serialize_to_array_end:eqproto.SpawnEvent) - return target; -} - -size_t SpawnEvent::ByteSizeLong() const { -// @@protoc_insertion_point(message_byte_size_start:eqproto.SpawnEvent) - size_t total_size = 0; - - if ((_internal_metadata_.have_unknown_fields() && ::google::protobuf::internal::GetProto3PreserveUnknownsDefault())) { - total_size += - ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( - (::google::protobuf::internal::GetProto3PreserveUnknownsDefault() ? _internal_metadata_.unknown_fields() : _internal_metadata_.default_instance())); - } - // string name = 8; - if (this->name().size() > 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->name()); - } - - // string suffix = 48; - if (this->suffix().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->suffix()); - } - - // string title = 56; - if (this->title().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->title()); - } - - // string lastName = 62; - if (this->lastname().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->lastname()); - } - - // string DestructibleModel = 82; - if (this->destructiblemodel().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->destructiblemodel()); - } - - // string DestructibleName2 = 83; - if (this->destructiblename2().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->destructiblename2()); - } - - // string DestructibleString = 84; - if (this->destructiblestring().size() > 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::StringSize( - this->destructiblestring()); - } - - // .eqproto.TextureProfile equipment = 52; - if (this->has_equipment()) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->equipment_); - } - - // .eqproto.TintProfile equipment_tint = 78; - if (this->has_equipment_tint()) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::MessageSize( - *this->equipment_tint_); - } - - // uint32 unknown0000 = 1; - if (this->unknown0000() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0000()); - } - - // uint32 gm = 2; - if (this->gm() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->gm()); - } - - // uint32 unknown0003 = 3; - if (this->unknown0003() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0003()); - } - - // uint32 aaitle = 4; - if (this->aaitle() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->aaitle()); - } - - // uint32 unknown0004 = 5; - if (this->unknown0004() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0004()); - } - - // uint32 anon = 6; - if (this->anon() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->anon()); - } - - // uint32 face = 7; - if (this->face() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->face()); - } - - // uint32 deity = 9; - if (this->deity() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->deity()); - } - - // uint32 unknown0073 = 10; - if (this->unknown0073() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0073()); - } - - // float size = 11; - if (this->size() != 0) { - total_size += 1 + 4; - } - - // uint32 unknown0079 = 12; - if (this->unknown0079() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0079()); - } - - // uint32 NPC = 13; - if (this->npc() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->npc()); - } - - // uint32 invis = 14; - if (this->invis() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->invis()); - } - - // uint32 haircolor = 15; - if (this->haircolor() != 0) { - total_size += 1 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->haircolor()); - } - - // uint32 curHp = 16; - if (this->curhp() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->curhp()); - } - - // uint32 max_hp = 17; - if (this->max_hp() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->max_hp()); - } - - // uint32 findable = 18; - if (this->findable() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->findable()); - } - - // uint32 unknown0089 = 19; - if (this->unknown0089() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0089()); - } - - // int32 deltaHeading = 20; - if (this->deltaheading() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->deltaheading()); - } - - // int32 x = 21; - if (this->x() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->x()); - } - - // int32 padding0054 = 22; - if (this->padding0054() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0054()); - } - - // int32 y = 23; - if (this->y() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->y()); - } - - // int32 animation = 24; - if (this->animation() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->animation()); - } - - // int32 padding0058 = 25; - if (this->padding0058() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0058()); - } - - // int32 z = 26; - if (this->z() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->z()); - } - - // int32 deltaY = 27; - if (this->deltay() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->deltay()); - } - - // int32 deltaX = 28; - if (this->deltax() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->deltax()); - } - - // uint32 heading = 29; - if (this->heading() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->heading()); - } - - // int32 padding0066 = 30; - if (this->padding0066() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0066()); - } - - // int32 deltaZ = 31; - if (this->deltaz() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->deltaz()); - } - - // int32 padding0070 = 32; - if (this->padding0070() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::Int32Size( - this->padding0070()); - } - - // uint32 eyecolor1 = 33; - if (this->eyecolor1() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->eyecolor1()); - } - - // uint32 unknown0115 = 34; - if (this->unknown0115() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0115()); - } - - // uint32 StandState = 35; - if (this->standstate() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->standstate()); - } - - // uint32 drakkin_heritage = 36; - if (this->drakkin_heritage() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->drakkin_heritage()); - } - - // uint32 drakkin_tattoo = 37; - if (this->drakkin_tattoo() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->drakkin_tattoo()); - } - - // uint32 drakkin_details = 38; - if (this->drakkin_details() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->drakkin_details()); - } - - // uint32 showhelm = 39; - if (this->showhelm() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->showhelm()); - } - - // uint32 unknown0140 = 40; - if (this->unknown0140() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0140()); - } - - // uint32 is_npc = 41; - if (this->is_npc() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->is_npc()); - } - - // uint32 hairstyle = 42; - if (this->hairstyle() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->hairstyle()); - } - - // uint32 beard = 43; - if (this->beard() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->beard()); - } - - // uint32 unknown0147 = 44; - if (this->unknown0147() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0147()); - } - - // uint32 level = 45; - if (this->level() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->level()); - } - - // uint32 PlayerState = 46; - if (this->playerstate() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->playerstate()); - } - - // uint32 beardcolor = 47; - if (this->beardcolor() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->beardcolor()); - } - - // uint32 petOwnerId = 49; - if (this->petownerid() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->petownerid()); - } - - // uint32 guildrank = 50; - if (this->guildrank() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->guildrank()); - } - - // uint32 unknown0194 = 51; - if (this->unknown0194() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0194()); - } - - // float runspeed = 53; - if (this->runspeed() != 0) { - total_size += 2 + 4; - } - - // uint32 afk = 54; - if (this->afk() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->afk()); - } - - // uint32 guildID = 55; - if (this->guildid() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->guildid()); - } - - // uint32 unknown0274 = 57; - if (this->unknown0274() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0274()); - } - - // uint32 set_to_0xFF = 58; - if (this->set_to_0xff() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->set_to_0xff()); - } - - // uint32 helm = 59; - if (this->helm() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->helm()); - } - - // uint32 race = 60; - if (this->race() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->race()); - } - - // uint32 unknown0288 = 61; - if (this->unknown0288() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0288()); - } - - // float walkspeed = 63; - if (this->walkspeed() != 0) { - total_size += 2 + 4; - } - - // uint32 unknown0328 = 64; - if (this->unknown0328() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0328()); - } - - // uint32 is_pet = 65; - if (this->is_pet() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->is_pet()); - } - - // uint32 light = 66; - if (this->light() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->light()); - } - - // uint32 class_ = 67; - if (this->class_() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->class_()); - } - - // uint32 eyecolor2 = 68; - if (this->eyecolor2() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->eyecolor2()); - } - - // uint32 flymode = 69; - if (this->flymode() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->flymode()); - } - - // uint32 gender = 70; - if (this->gender() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->gender()); - } - - // uint32 bodytype = 71; - if (this->bodytype() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->bodytype()); - } - - // uint32 unknown0336 = 72; - if (this->unknown0336() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0336()); - } - - // uint32 equip_chest2 = 73; - if (this->equip_chest2() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->equip_chest2()); - } - - // uint32 mount_color = 74; - if (this->mount_color() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->mount_color()); - } - - // uint32 spawnId = 75; - if (this->spawnid() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->spawnid()); - } - - // uint32 unknown0344 = 76; - if (this->unknown0344() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->unknown0344()); - } - - // uint32 IsMercenary = 77; - if (this->ismercenary() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->ismercenary()); - } - - // uint32 lfg = 79; - if (this->lfg() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->lfg()); - } - - // uint32 DestructibleAppearance = 85; - if (this->destructibleappearance() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleappearance()); - } - - // uint32 DestructibleUnk1 = 86; - if (this->destructibleunk1() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk1()); - } - - // uint32 DestructibleID1 = 87; - if (this->destructibleid1() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleid1()); - } - - // uint32 DestructibleID2 = 88; - if (this->destructibleid2() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleid2()); - } - - // uint32 DestructibleID3 = 89; - if (this->destructibleid3() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleid3()); - } - - // uint32 DestructibleID4 = 90; - if (this->destructibleid4() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleid4()); - } - - // uint32 DestructibleUnk2 = 91; - if (this->destructibleunk2() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk2()); - } - - // uint32 DestructibleUnk3 = 92; - if (this->destructibleunk3() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk3()); - } - - // uint32 DestructibleUnk4 = 93; - if (this->destructibleunk4() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk4()); - } - - // bool DestructibleObject = 80; - if (this->destructibleobject() != 0) { - total_size += 2 + 1; - } - - // bool targetable_with_hotkey = 99; - if (this->targetable_with_hotkey() != 0) { - total_size += 2 + 1; - } - - // bool show_name = 100; - if (this->show_name() != 0) { - total_size += 2 + 1; - } - - // uint32 DestructibleUnk5 = 94; - if (this->destructibleunk5() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk5()); - } - - // uint32 DestructibleUnk6 = 95; - if (this->destructibleunk6() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk6()); - } - - // uint32 DestructibleUnk7 = 96; - if (this->destructibleunk7() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk7()); - } - - // uint32 DestructibleUnk8 = 97; - if (this->destructibleunk8() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk8()); - } - - // uint32 DestructibleUnk9 = 98; - if (this->destructibleunk9() != 0) { - total_size += 2 + - ::google::protobuf::internal::WireFormatLite::UInt32Size( - this->destructibleunk9()); - } - - int cached_size = ::google::protobuf::internal::ToCachedSize(total_size); - GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); - _cached_size_ = cached_size; - GOOGLE_SAFE_CONCURRENT_WRITES_END(); - return total_size; -} - -void SpawnEvent::MergeFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_merge_from_start:eqproto.SpawnEvent) - GOOGLE_DCHECK_NE(&from, this); - const SpawnEvent* source = - ::google::protobuf::internal::DynamicCastToGenerated( - &from); - if (source == NULL) { - // @@protoc_insertion_point(generalized_merge_from_cast_fail:eqproto.SpawnEvent) - ::google::protobuf::internal::ReflectionOps::Merge(from, this); - } else { - // @@protoc_insertion_point(generalized_merge_from_cast_success:eqproto.SpawnEvent) - MergeFrom(*source); - } -} - -void SpawnEvent::MergeFrom(const SpawnEvent& from) { -// @@protoc_insertion_point(class_specific_merge_from_start:eqproto.SpawnEvent) - GOOGLE_DCHECK_NE(&from, this); - _internal_metadata_.MergeFrom(from._internal_metadata_); - ::google::protobuf::uint32 cached_has_bits = 0; - (void) cached_has_bits; - - if (from.name().size() > 0) { - - name_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.name_); - } - if (from.suffix().size() > 0) { - - suffix_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.suffix_); - } - if (from.title().size() > 0) { - - title_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.title_); - } - if (from.lastname().size() > 0) { - - lastname_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.lastname_); - } - if (from.destructiblemodel().size() > 0) { - - destructiblemodel_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblemodel_); - } - if (from.destructiblename2().size() > 0) { - - destructiblename2_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblename2_); - } - if (from.destructiblestring().size() > 0) { - - destructiblestring_.AssignWithDefault(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from.destructiblestring_); - } - if (from.has_equipment()) { - mutable_equipment()->::eqproto::TextureProfile::MergeFrom(from.equipment()); - } - if (from.has_equipment_tint()) { - mutable_equipment_tint()->::eqproto::TintProfile::MergeFrom(from.equipment_tint()); - } - if (from.unknown0000() != 0) { - set_unknown0000(from.unknown0000()); - } - if (from.gm() != 0) { - set_gm(from.gm()); - } - if (from.unknown0003() != 0) { - set_unknown0003(from.unknown0003()); - } - if (from.aaitle() != 0) { - set_aaitle(from.aaitle()); - } - if (from.unknown0004() != 0) { - set_unknown0004(from.unknown0004()); - } - if (from.anon() != 0) { - set_anon(from.anon()); - } - if (from.face() != 0) { - set_face(from.face()); - } - if (from.deity() != 0) { - set_deity(from.deity()); - } - if (from.unknown0073() != 0) { - set_unknown0073(from.unknown0073()); - } - if (from.size() != 0) { - set_size(from.size()); - } - if (from.unknown0079() != 0) { - set_unknown0079(from.unknown0079()); - } - if (from.npc() != 0) { - set_npc(from.npc()); - } - if (from.invis() != 0) { - set_invis(from.invis()); - } - if (from.haircolor() != 0) { - set_haircolor(from.haircolor()); - } - if (from.curhp() != 0) { - set_curhp(from.curhp()); - } - if (from.max_hp() != 0) { - set_max_hp(from.max_hp()); - } - if (from.findable() != 0) { - set_findable(from.findable()); - } - if (from.unknown0089() != 0) { - set_unknown0089(from.unknown0089()); - } - if (from.deltaheading() != 0) { - set_deltaheading(from.deltaheading()); - } - if (from.x() != 0) { - set_x(from.x()); - } - if (from.padding0054() != 0) { - set_padding0054(from.padding0054()); - } - if (from.y() != 0) { - set_y(from.y()); - } - if (from.animation() != 0) { - set_animation(from.animation()); - } - if (from.padding0058() != 0) { - set_padding0058(from.padding0058()); - } - if (from.z() != 0) { - set_z(from.z()); - } - if (from.deltay() != 0) { - set_deltay(from.deltay()); - } - if (from.deltax() != 0) { - set_deltax(from.deltax()); - } - if (from.heading() != 0) { - set_heading(from.heading()); - } - if (from.padding0066() != 0) { - set_padding0066(from.padding0066()); - } - if (from.deltaz() != 0) { - set_deltaz(from.deltaz()); - } - if (from.padding0070() != 0) { - set_padding0070(from.padding0070()); - } - if (from.eyecolor1() != 0) { - set_eyecolor1(from.eyecolor1()); - } - if (from.unknown0115() != 0) { - set_unknown0115(from.unknown0115()); - } - if (from.standstate() != 0) { - set_standstate(from.standstate()); - } - if (from.drakkin_heritage() != 0) { - set_drakkin_heritage(from.drakkin_heritage()); - } - if (from.drakkin_tattoo() != 0) { - set_drakkin_tattoo(from.drakkin_tattoo()); - } - if (from.drakkin_details() != 0) { - set_drakkin_details(from.drakkin_details()); - } - if (from.showhelm() != 0) { - set_showhelm(from.showhelm()); - } - if (from.unknown0140() != 0) { - set_unknown0140(from.unknown0140()); - } - if (from.is_npc() != 0) { - set_is_npc(from.is_npc()); - } - if (from.hairstyle() != 0) { - set_hairstyle(from.hairstyle()); - } - if (from.beard() != 0) { - set_beard(from.beard()); - } - if (from.unknown0147() != 0) { - set_unknown0147(from.unknown0147()); - } - if (from.level() != 0) { - set_level(from.level()); - } - if (from.playerstate() != 0) { - set_playerstate(from.playerstate()); - } - if (from.beardcolor() != 0) { - set_beardcolor(from.beardcolor()); - } - if (from.petownerid() != 0) { - set_petownerid(from.petownerid()); - } - if (from.guildrank() != 0) { - set_guildrank(from.guildrank()); - } - if (from.unknown0194() != 0) { - set_unknown0194(from.unknown0194()); - } - if (from.runspeed() != 0) { - set_runspeed(from.runspeed()); - } - if (from.afk() != 0) { - set_afk(from.afk()); - } - if (from.guildid() != 0) { - set_guildid(from.guildid()); - } - if (from.unknown0274() != 0) { - set_unknown0274(from.unknown0274()); - } - if (from.set_to_0xff() != 0) { - set_set_to_0xff(from.set_to_0xff()); - } - if (from.helm() != 0) { - set_helm(from.helm()); - } - if (from.race() != 0) { - set_race(from.race()); - } - if (from.unknown0288() != 0) { - set_unknown0288(from.unknown0288()); - } - if (from.walkspeed() != 0) { - set_walkspeed(from.walkspeed()); - } - if (from.unknown0328() != 0) { - set_unknown0328(from.unknown0328()); - } - if (from.is_pet() != 0) { - set_is_pet(from.is_pet()); - } - if (from.light() != 0) { - set_light(from.light()); - } - if (from.class_() != 0) { - set_class_(from.class_()); - } - if (from.eyecolor2() != 0) { - set_eyecolor2(from.eyecolor2()); - } - if (from.flymode() != 0) { - set_flymode(from.flymode()); - } - if (from.gender() != 0) { - set_gender(from.gender()); - } - if (from.bodytype() != 0) { - set_bodytype(from.bodytype()); - } - if (from.unknown0336() != 0) { - set_unknown0336(from.unknown0336()); - } - if (from.equip_chest2() != 0) { - set_equip_chest2(from.equip_chest2()); - } - if (from.mount_color() != 0) { - set_mount_color(from.mount_color()); - } - if (from.spawnid() != 0) { - set_spawnid(from.spawnid()); - } - if (from.unknown0344() != 0) { - set_unknown0344(from.unknown0344()); - } - if (from.ismercenary() != 0) { - set_ismercenary(from.ismercenary()); - } - if (from.lfg() != 0) { - set_lfg(from.lfg()); - } - if (from.destructibleappearance() != 0) { - set_destructibleappearance(from.destructibleappearance()); - } - if (from.destructibleunk1() != 0) { - set_destructibleunk1(from.destructibleunk1()); - } - if (from.destructibleid1() != 0) { - set_destructibleid1(from.destructibleid1()); - } - if (from.destructibleid2() != 0) { - set_destructibleid2(from.destructibleid2()); - } - if (from.destructibleid3() != 0) { - set_destructibleid3(from.destructibleid3()); - } - if (from.destructibleid4() != 0) { - set_destructibleid4(from.destructibleid4()); - } - if (from.destructibleunk2() != 0) { - set_destructibleunk2(from.destructibleunk2()); - } - if (from.destructibleunk3() != 0) { - set_destructibleunk3(from.destructibleunk3()); - } - if (from.destructibleunk4() != 0) { - set_destructibleunk4(from.destructibleunk4()); - } - if (from.destructibleobject() != 0) { - set_destructibleobject(from.destructibleobject()); - } - if (from.targetable_with_hotkey() != 0) { - set_targetable_with_hotkey(from.targetable_with_hotkey()); - } - if (from.show_name() != 0) { - set_show_name(from.show_name()); - } - if (from.destructibleunk5() != 0) { - set_destructibleunk5(from.destructibleunk5()); - } - if (from.destructibleunk6() != 0) { - set_destructibleunk6(from.destructibleunk6()); - } - if (from.destructibleunk7() != 0) { - set_destructibleunk7(from.destructibleunk7()); - } - if (from.destructibleunk8() != 0) { - set_destructibleunk8(from.destructibleunk8()); - } - if (from.destructibleunk9() != 0) { - set_destructibleunk9(from.destructibleunk9()); - } -} - -void SpawnEvent::CopyFrom(const ::google::protobuf::Message& from) { -// @@protoc_insertion_point(generalized_copy_from_start:eqproto.SpawnEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -void SpawnEvent::CopyFrom(const SpawnEvent& from) { -// @@protoc_insertion_point(class_specific_copy_from_start:eqproto.SpawnEvent) - if (&from == this) return; - Clear(); - MergeFrom(from); -} - -bool SpawnEvent::IsInitialized() const { - return true; -} - -void SpawnEvent::Swap(SpawnEvent* other) { - if (other == this) return; - InternalSwap(other); -} -void SpawnEvent::InternalSwap(SpawnEvent* other) { - using std::swap; - name_.Swap(&other->name_); - suffix_.Swap(&other->suffix_); - title_.Swap(&other->title_); - lastname_.Swap(&other->lastname_); - destructiblemodel_.Swap(&other->destructiblemodel_); - destructiblename2_.Swap(&other->destructiblename2_); - destructiblestring_.Swap(&other->destructiblestring_); - swap(equipment_, other->equipment_); - swap(equipment_tint_, other->equipment_tint_); - swap(unknown0000_, other->unknown0000_); - swap(gm_, other->gm_); - swap(unknown0003_, other->unknown0003_); - swap(aaitle_, other->aaitle_); - swap(unknown0004_, other->unknown0004_); - swap(anon_, other->anon_); - swap(face_, other->face_); - swap(deity_, other->deity_); - swap(unknown0073_, other->unknown0073_); - swap(size_, other->size_); - swap(unknown0079_, other->unknown0079_); - swap(npc_, other->npc_); - swap(invis_, other->invis_); - swap(haircolor_, other->haircolor_); - swap(curhp_, other->curhp_); - swap(max_hp_, other->max_hp_); - swap(findable_, other->findable_); - swap(unknown0089_, other->unknown0089_); - swap(deltaheading_, other->deltaheading_); - swap(x_, other->x_); - swap(padding0054_, other->padding0054_); - swap(y_, other->y_); - swap(animation_, other->animation_); - swap(padding0058_, other->padding0058_); - swap(z_, other->z_); - swap(deltay_, other->deltay_); - swap(deltax_, other->deltax_); - swap(heading_, other->heading_); - swap(padding0066_, other->padding0066_); - swap(deltaz_, other->deltaz_); - swap(padding0070_, other->padding0070_); - swap(eyecolor1_, other->eyecolor1_); - swap(unknown0115_, other->unknown0115_); - swap(standstate_, other->standstate_); - swap(drakkin_heritage_, other->drakkin_heritage_); - swap(drakkin_tattoo_, other->drakkin_tattoo_); - swap(drakkin_details_, other->drakkin_details_); - swap(showhelm_, other->showhelm_); - swap(unknown0140_, other->unknown0140_); - swap(is_npc_, other->is_npc_); - swap(hairstyle_, other->hairstyle_); - swap(beard_, other->beard_); - swap(unknown0147_, other->unknown0147_); - swap(level_, other->level_); - swap(playerstate_, other->playerstate_); - swap(beardcolor_, other->beardcolor_); - swap(petownerid_, other->petownerid_); - swap(guildrank_, other->guildrank_); - swap(unknown0194_, other->unknown0194_); - swap(runspeed_, other->runspeed_); - swap(afk_, other->afk_); - swap(guildid_, other->guildid_); - swap(unknown0274_, other->unknown0274_); - swap(set_to_0xff_, other->set_to_0xff_); - swap(helm_, other->helm_); - swap(race_, other->race_); - swap(unknown0288_, other->unknown0288_); - swap(walkspeed_, other->walkspeed_); - swap(unknown0328_, other->unknown0328_); - swap(is_pet_, other->is_pet_); - swap(light_, other->light_); - swap(class__, other->class__); - swap(eyecolor2_, other->eyecolor2_); - swap(flymode_, other->flymode_); - swap(gender_, other->gender_); - swap(bodytype_, other->bodytype_); - swap(unknown0336_, other->unknown0336_); - swap(equip_chest2_, other->equip_chest2_); - swap(mount_color_, other->mount_color_); - swap(spawnid_, other->spawnid_); - swap(unknown0344_, other->unknown0344_); - swap(ismercenary_, other->ismercenary_); - swap(lfg_, other->lfg_); - swap(destructibleappearance_, other->destructibleappearance_); - swap(destructibleunk1_, other->destructibleunk1_); - swap(destructibleid1_, other->destructibleid1_); - swap(destructibleid2_, other->destructibleid2_); - swap(destructibleid3_, other->destructibleid3_); - swap(destructibleid4_, other->destructibleid4_); - swap(destructibleunk2_, other->destructibleunk2_); - swap(destructibleunk3_, other->destructibleunk3_); - swap(destructibleunk4_, other->destructibleunk4_); - swap(destructibleobject_, other->destructibleobject_); - swap(targetable_with_hotkey_, other->targetable_with_hotkey_); - swap(show_name_, other->show_name_); - swap(destructibleunk5_, other->destructibleunk5_); - swap(destructibleunk6_, other->destructibleunk6_); - swap(destructibleunk7_, other->destructibleunk7_); - swap(destructibleunk8_, other->destructibleunk8_); - swap(destructibleunk9_, other->destructibleunk9_); - _internal_metadata_.Swap(&other->_internal_metadata_); - swap(_cached_size_, other->_cached_size_); -} - -::google::protobuf::Metadata SpawnEvent::GetMetadata() const { - protobuf_message_2eproto::protobuf_AssignDescriptorsOnce(); - return ::protobuf_message_2eproto::file_level_metadata[kIndexInFileMessages]; -} - - -// @@protoc_insertion_point(namespace_scope) -} // namespace eqproto - -// @@protoc_insertion_point(global_scope) diff --git a/common/proto/message.pb.h b/common/proto/message.pb.h deleted file mode 100644 index c1028472b..000000000 --- a/common/proto/message.pb.h +++ /dev/null @@ -1,9458 +0,0 @@ -// Generated by the protocol buffer compiler. DO NOT EDIT! -// source: message.proto - -#ifndef PROTOBUF_message_2eproto__INCLUDED -#define PROTOBUF_message_2eproto__INCLUDED - -#include - -#include - -#if GOOGLE_PROTOBUF_VERSION < 3005000 -#error This file was generated by a newer version of protoc which is -#error incompatible with your Protocol Buffer headers. Please update -#error your headers. -#endif -#if 3005001 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION -#error This file was generated by an older version of protoc which is -#error incompatible with your Protocol Buffer headers. Please -#error regenerate this file with a newer version of protoc. -#endif - -#include -#include -#include -#include -#include -#include -#include -#include // IWYU pragma: export -#include // IWYU pragma: export -#include -#include -// @@protoc_insertion_point(includes) - -namespace protobuf_message_2eproto { -// Internal implementation detail -- do not use these members. -struct TableStruct { - static const ::google::protobuf::internal::ParseTableField entries[]; - static const ::google::protobuf::internal::AuxillaryParseTableField aux[]; - static const ::google::protobuf::internal::ParseTable schema[21]; - static const ::google::protobuf::internal::FieldMetadata field_metadata[]; - static const ::google::protobuf::internal::SerializationTable serialization_table[]; - static const ::google::protobuf::uint32 offsets[]; -}; -void AddDescriptors(); -void InitDefaultsChannelMessageImpl(); -void InitDefaultsChannelMessage(); -void InitDefaultsCommandMessageImpl(); -void InitDefaultsCommandMessage(); -void InitDefaultsDailyGainImpl(); -void InitDefaultsDailyGain(); -void InitDefaultsEntityImpl(); -void InitDefaultsEntity(); -void InitDefaultsEntitiesImpl(); -void InitDefaultsEntities(); -void InitDefaultsPositionImpl(); -void InitDefaultsPosition(); -void InitDefaultsTextureProfileImpl(); -void InitDefaultsTextureProfile(); -void InitDefaultsTextureImpl(); -void InitDefaultsTexture(); -void InitDefaultsTintProfileImpl(); -void InitDefaultsTintProfile(); -void InitDefaultsTintImpl(); -void InitDefaultsTint(); -void InitDefaultsEventImpl(); -void InitDefaultsEvent(); -void InitDefaultsDeathEventImpl(); -void InitDefaultsDeathEvent(); -void InitDefaultsDamageEventImpl(); -void InitDefaultsDamageEvent(); -void InitDefaultsEntityEventImpl(); -void InitDefaultsEntityEvent(); -void InitDefaultsChannelMessageEventImpl(); -void InitDefaultsChannelMessageEvent(); -void InitDefaultsWearChangeEventImpl(); -void InitDefaultsWearChangeEvent(); -void InitDefaultsDeleteSpawnEventImpl(); -void InitDefaultsDeleteSpawnEvent(); -void InitDefaultsHPEventImpl(); -void InitDefaultsHPEvent(); -void InitDefaultsPlayerPositionUpdateEventImpl(); -void InitDefaultsPlayerPositionUpdateEvent(); -void InitDefaultsAnimationEventImpl(); -void InitDefaultsAnimationEvent(); -void InitDefaultsSpawnEventImpl(); -void InitDefaultsSpawnEvent(); -inline void InitDefaults() { - InitDefaultsChannelMessage(); - InitDefaultsCommandMessage(); - InitDefaultsDailyGain(); - InitDefaultsEntity(); - InitDefaultsEntities(); - InitDefaultsPosition(); - InitDefaultsTextureProfile(); - InitDefaultsTexture(); - InitDefaultsTintProfile(); - InitDefaultsTint(); - InitDefaultsEvent(); - InitDefaultsDeathEvent(); - InitDefaultsDamageEvent(); - InitDefaultsEntityEvent(); - InitDefaultsChannelMessageEvent(); - InitDefaultsWearChangeEvent(); - InitDefaultsDeleteSpawnEvent(); - InitDefaultsHPEvent(); - InitDefaultsPlayerPositionUpdateEvent(); - InitDefaultsAnimationEvent(); - InitDefaultsSpawnEvent(); -} -} // namespace protobuf_message_2eproto -namespace eqproto { -class AnimationEvent; -class AnimationEventDefaultTypeInternal; -extern AnimationEventDefaultTypeInternal _AnimationEvent_default_instance_; -class ChannelMessage; -class ChannelMessageDefaultTypeInternal; -extern ChannelMessageDefaultTypeInternal _ChannelMessage_default_instance_; -class ChannelMessageEvent; -class ChannelMessageEventDefaultTypeInternal; -extern ChannelMessageEventDefaultTypeInternal _ChannelMessageEvent_default_instance_; -class CommandMessage; -class CommandMessageDefaultTypeInternal; -extern CommandMessageDefaultTypeInternal _CommandMessage_default_instance_; -class DailyGain; -class DailyGainDefaultTypeInternal; -extern DailyGainDefaultTypeInternal _DailyGain_default_instance_; -class DamageEvent; -class DamageEventDefaultTypeInternal; -extern DamageEventDefaultTypeInternal _DamageEvent_default_instance_; -class DeathEvent; -class DeathEventDefaultTypeInternal; -extern DeathEventDefaultTypeInternal _DeathEvent_default_instance_; -class DeleteSpawnEvent; -class DeleteSpawnEventDefaultTypeInternal; -extern DeleteSpawnEventDefaultTypeInternal _DeleteSpawnEvent_default_instance_; -class Entities; -class EntitiesDefaultTypeInternal; -extern EntitiesDefaultTypeInternal _Entities_default_instance_; -class Entity; -class EntityDefaultTypeInternal; -extern EntityDefaultTypeInternal _Entity_default_instance_; -class EntityEvent; -class EntityEventDefaultTypeInternal; -extern EntityEventDefaultTypeInternal _EntityEvent_default_instance_; -class Event; -class EventDefaultTypeInternal; -extern EventDefaultTypeInternal _Event_default_instance_; -class HPEvent; -class HPEventDefaultTypeInternal; -extern HPEventDefaultTypeInternal _HPEvent_default_instance_; -class PlayerPositionUpdateEvent; -class PlayerPositionUpdateEventDefaultTypeInternal; -extern PlayerPositionUpdateEventDefaultTypeInternal _PlayerPositionUpdateEvent_default_instance_; -class Position; -class PositionDefaultTypeInternal; -extern PositionDefaultTypeInternal _Position_default_instance_; -class SpawnEvent; -class SpawnEventDefaultTypeInternal; -extern SpawnEventDefaultTypeInternal _SpawnEvent_default_instance_; -class Texture; -class TextureDefaultTypeInternal; -extern TextureDefaultTypeInternal _Texture_default_instance_; -class TextureProfile; -class TextureProfileDefaultTypeInternal; -extern TextureProfileDefaultTypeInternal _TextureProfile_default_instance_; -class Tint; -class TintDefaultTypeInternal; -extern TintDefaultTypeInternal _Tint_default_instance_; -class TintProfile; -class TintProfileDefaultTypeInternal; -extern TintProfileDefaultTypeInternal _TintProfile_default_instance_; -class WearChangeEvent; -class WearChangeEventDefaultTypeInternal; -extern WearChangeEventDefaultTypeInternal _WearChangeEvent_default_instance_; -} // namespace eqproto -namespace eqproto { - -enum OpCode { - OP_Unknown = 0, - OP_ExploreUnknown = 1, - OP_0x0193 = 2, - OP_0x0347 = 3, - OP_AAAction = 4, - OP_AAExpUpdate = 5, - OP_AcceptNewTask = 6, - OP_AckPacket = 7, - OP_Action = 8, - OP_Action2 = 9, - OP_AddNimbusEffect = 10, - OP_AdventureData = 11, - OP_AdventureDetails = 12, - OP_AdventureFinish = 13, - OP_AdventureInfo = 14, - OP_AdventureInfoRequest = 15, - OP_AdventureLeaderboardReply = 16, - OP_AdventureLeaderboardRequest = 17, - OP_AdventureMerchantPurchase = 18, - OP_AdventureMerchantRequest = 19, - OP_AdventureMerchantResponse = 20, - OP_AdventureMerchantSell = 21, - OP_AdventurePointsUpdate = 22, - OP_AdventureRequest = 23, - OP_AdventureStatsReply = 24, - OP_AdventureStatsRequest = 25, - OP_AdventureUpdate = 26, - OP_AggroMeterLockTarget = 27, - OP_AggroMeterTargetInfo = 28, - OP_AggroMeterUpdate = 29, - OP_AltCurrency = 30, - OP_AltCurrencyMerchantReply = 31, - OP_AltCurrencyMerchantRequest = 32, - OP_AltCurrencyPurchase = 33, - OP_AltCurrencyReclaim = 34, - OP_AltCurrencySell = 35, - OP_AltCurrencySellSelection = 36, - OP_Animation = 37, - OP_AnnoyingZoneUnknown = 38, - OP_ApplyPoison = 39, - OP_ApproveName = 40, - OP_ApproveWorld = 41, - OP_ApproveZone = 42, - OP_Assist = 43, - OP_AssistGroup = 44, - OP_AugmentInfo = 45, - OP_AugmentItem = 46, - OP_AutoAttack = 47, - OP_AutoAttack2 = 48, - OP_AutoFire = 49, - OP_Bandolier = 50, - OP_BankerChange = 51, - OP_Barter = 52, - OP_Bazaar = 53, - OP_BazaarInspect = 54, - OP_BazaarSearch = 55, - OP_BecomeCorpse = 56, - OP_BecomeTrader = 57, - OP_Begging = 58, - OP_BeginCast = 59, - OP_Bind_Wound = 60, - OP_BlockedBuffs = 61, - OP_BoardBoat = 62, - OP_Buff = 63, - OP_BuffCreate = 64, - OP_BuffRemoveRequest = 65, - OP_Bug = 66, - OP_CameraEffect = 67, - OP_Camp = 68, - OP_CancelSneakHide = 69, - OP_CancelTask = 70, - OP_CancelTrade = 71, - OP_CastSpell = 72, - OP_ChangeSize = 73, - OP_ChannelMessage = 74, - OP_CharacterCreate = 75, - OP_CharacterCreateRequest = 76, - OP_CharInventory = 77, - OP_Charm = 78, - OP_ChatMessage = 79, - OP_ClearAA = 80, - OP_ClearBlockedBuffs = 81, - OP_ClearLeadershipAbilities = 82, - OP_ClearNPCMarks = 83, - OP_ClearObject = 84, - OP_ClearSurname = 85, - OP_ClickDoor = 86, - OP_ClickObject = 87, - OP_ClickObjectAction = 88, - OP_ClientError = 89, - OP_ClientReady = 90, - OP_ClientTimeStamp = 91, - OP_ClientUpdate = 92, - OP_CloseContainer = 93, - OP_CloseTributeMaster = 94, - OP_ColoredText = 95, - OP_CombatAbility = 96, - OP_Command = 97, - OP_CompletedTasks = 98, - OP_ConfirmDelete = 99, - OP_Consent = 100, - OP_ConsentDeny = 101, - OP_ConsentResponse = 102, - OP_Consider = 103, - OP_ConsiderCorpse = 104, - OP_Consume = 105, - OP_ControlBoat = 106, - OP_CorpseDrag = 107, - OP_CorpseDrop = 108, - OP_CrashDump = 109, - OP_CrystalCountUpdate = 110, - OP_CrystalCreate = 111, - OP_CrystalReclaim = 112, - OP_CustomTitles = 113, - OP_Damage = 114, - OP_Death = 115, - OP_DelegateAbility = 116, - OP_DeleteCharacter = 117, - OP_DeleteCharge = 118, - OP_DeleteItem = 119, - OP_DeletePetition = 120, - OP_DeleteSpawn = 121, - OP_DeleteSpell = 122, - OP_DenyResponse = 123, - OP_Disarm = 124, - OP_DisarmTraps = 125, - OP_DisciplineTimer = 126, - OP_DisciplineUpdate = 127, - OP_DiscordMerchantInventory = 128, - OP_DoGroupLeadershipAbility = 129, - OP_DuelResponse = 130, - OP_DuelResponse2 = 131, - OP_DumpName = 132, - OP_Dye = 133, - OP_DynamicWall = 134, - OP_DzAddPlayer = 135, - OP_DzChooseZone = 136, - OP_DzCompass = 137, - OP_DzExpeditionEndsWarning = 138, - OP_DzExpeditionInfo = 139, - OP_DzExpeditionList = 140, - OP_DzJoinExpeditionConfirm = 141, - OP_DzJoinExpeditionReply = 142, - OP_DzLeaderStatus = 143, - OP_DzListTimers = 144, - OP_DzMakeLeader = 145, - OP_DzMemberList = 146, - OP_DzMemberStatus = 147, - OP_DzPlayerList = 148, - OP_DzQuit = 149, - OP_DzRemovePlayer = 150, - OP_DzSwapPlayer = 151, - OP_Emote = 152, - OP_EndLootRequest = 153, - OP_EnduranceUpdate = 154, - OP_EnterChat = 155, - OP_EnterWorld = 156, - OP_EnvDamage = 157, - OP_ExpansionInfo = 158, - OP_ExpUpdate = 159, - OP_FaceChange = 160, - OP_Feedback = 161, - OP_FeignDeath = 162, - OP_FellowshipUpdate = 163, - OP_FindPersonReply = 164, - OP_FindPersonRequest = 165, - OP_FinishTrade = 166, - OP_FinishWindow = 167, - OP_FinishWindow2 = 168, - OP_Fishing = 169, - OP_Fling = 170, - OP_FloatListThing = 171, - OP_Forage = 172, - OP_ForceFindPerson = 173, - OP_FormattedMessage = 174, - OP_FriendsWho = 175, - OP_GetGuildMOTD = 176, - OP_GetGuildMOTDReply = 177, - OP_GetGuildsList = 178, - OP_GiveMoney = 179, - OP_GMApproval = 180, - OP_GMBecomeNPC = 181, - OP_GMDelCorpse = 182, - OP_GMEmoteZone = 183, - OP_GMEndTraining = 184, - OP_GMEndTrainingResponse = 185, - OP_GMFind = 186, - OP_GMGoto = 187, - OP_GMHideMe = 188, - OP_GMKick = 189, - OP_GMKill = 190, - OP_GMLastName = 191, - OP_GMNameChange = 192, - OP_GMSearchCorpse = 193, - OP_GMServers = 194, - OP_GMSummon = 195, - OP_GMToggle = 196, - OP_GMTraining = 197, - OP_GMTrainSkill = 198, - OP_GMTrainSkillConfirm = 199, - OP_GMZoneRequest = 200, - OP_GMZoneRequest2 = 201, - OP_GroundSpawn = 202, - OP_GroupAcknowledge = 203, - OP_GroupCancelInvite = 204, - OP_GroupDelete = 205, - OP_GroupDisband = 206, - OP_GroupDisbandOther = 207, - OP_GroupDisbandYou = 208, - OP_GroupFollow = 209, - OP_GroupFollow2 = 210, - OP_GroupInvite = 211, - OP_GroupInvite2 = 212, - OP_GroupLeaderChange = 213, - OP_GroupLeadershipAAUpdate = 214, - OP_GroupMakeLeader = 215, - OP_GroupMentor = 216, - OP_GroupRoles = 217, - OP_GroupUpdate = 218, - OP_GroupUpdateB = 219, - OP_GroupUpdateLeaderAA = 220, - OP_GuildBank = 221, - OP_GuildBankItemList = 222, - OP_GuildCreate = 223, - OP_GuildDelete = 224, - OP_GuildDemote = 225, - OP_GuildInvite = 226, - OP_GuildInviteAccept = 227, - OP_GuildLeader = 228, - OP_GuildManageAdd = 229, - OP_GuildManageBanker = 230, - OP_GuildManageRemove = 231, - OP_GuildManageStatus = 232, - OP_GuildMemberLevelUpdate = 233, - OP_GuildMemberList = 234, - OP_GuildMemberUpdate = 235, - OP_GuildMOTD = 236, - OP_GuildPeace = 237, - OP_GuildPromote = 238, - OP_GuildPublicNote = 239, - OP_GuildRemove = 240, - OP_GuildsList = 241, - OP_GuildStatus = 242, - OP_GuildTributeInfo = 243, - OP_GuildUpdateURLAndChannel = 244, - OP_GuildWar = 245, - OP_Heartbeat = 246, - OP_Hide = 247, - OP_HideCorpse = 248, - OP_HPUpdate = 249, - OP_Illusion = 250, - OP_IncreaseStats = 251, - OP_InitialHPUpdate = 252, - OP_InitialMobHealth = 253, - OP_InspectAnswer = 254, - OP_InspectBuffs = 255, - OP_InspectMessageUpdate = 256, - OP_InspectRequest = 257, - OP_InstillDoubt = 258, - OP_InterruptCast = 259, - OP_ItemLinkClick = 260, - OP_ItemLinkResponse = 261, - OP_ItemLinkText = 262, - OP_ItemName = 263, - OP_ItemPacket = 264, - OP_ItemPreview = 265, - OP_ItemRecastDelay = 266, - OP_ItemVerifyReply = 267, - OP_ItemVerifyRequest = 268, - OP_ItemViewUnknown = 269, - OP_Jump = 270, - OP_KeyRing = 271, - OP_KnowledgeBase = 272, - OP_LDoNButton = 273, - OP_LDoNDisarmTraps = 274, - OP_LDoNInspect = 275, - OP_LDoNOpen = 276, - OP_LDoNPickLock = 277, - OP_LDoNSenseTraps = 278, - OP_LeadershipExpToggle = 279, - OP_LeadershipExpUpdate = 280, - OP_LeaveAdventure = 281, - OP_LeaveBoat = 282, - OP_LevelAppearance = 283, - OP_LevelUpdate = 284, - OP_LFGAppearance = 285, - OP_LFGCommand = 286, - OP_LFGGetMatchesRequest = 287, - OP_LFGGetMatchesResponse = 288, - OP_LFGResponse = 289, - OP_LFGuild = 290, - OP_LFPCommand = 291, - OP_LFPGetMatchesRequest = 292, - OP_LFPGetMatchesResponse = 293, - OP_LinkedReuse = 294, - OP_LoadSpellSet = 295, - OP_LocInfo = 296, - OP_LockoutTimerInfo = 297, - OP_Login = 298, - OP_LoginAccepted = 299, - OP_LoginComplete = 300, - OP_LoginUnknown1 = 301, - OP_LoginUnknown2 = 302, - OP_Logout = 303, - OP_LogoutReply = 304, - OP_LogServer = 305, - OP_LootComplete = 306, - OP_LootItem = 307, - OP_LootRequest = 308, - OP_ManaChange = 309, - OP_ManaUpdate = 310, - OP_MarkNPC = 311, - OP_Marquee = 312, - OP_MemorizeSpell = 313, - OP_Mend = 314, - OP_MendHPUpdate = 315, - OP_MercenaryAssign = 316, - OP_MercenaryCommand = 317, - OP_MercenaryDataRequest = 318, - OP_MercenaryDataResponse = 319, - OP_MercenaryDataUpdate = 320, - OP_MercenaryDataUpdateRequest = 321, - OP_MercenaryDismiss = 322, - OP_MercenaryHire = 323, - OP_MercenarySuspendRequest = 324, - OP_MercenarySuspendResponse = 325, - OP_MercenaryTimer = 326, - OP_MercenaryTimerRequest = 327, - OP_MercenaryUnknown1 = 328, - OP_MercenaryUnsuspendResponse = 329, - OP_MobEnduranceUpdate = 330, - OP_MobHealth = 331, - OP_MobManaUpdate = 332, - OP_MobRename = 333, - OP_MobUpdate = 334, - OP_MoneyOnCorpse = 335, - OP_MoneyUpdate = 336, - OP_MOTD = 337, - OP_MoveCoin = 338, - OP_MoveDoor = 339, - OP_MoveItem = 340, - OP_MoveLogDisregard = 341, - OP_MoveLogRequest = 342, - OP_MultiLineMsg = 343, - OP_NewSpawn = 344, - OP_NewTitlesAvailable = 345, - OP_NewZone = 346, - OP_OnLevelMessage = 347, - OP_OpenContainer = 348, - OP_OpenDiscordMerchant = 349, - OP_OpenGuildTributeMaster = 350, - OP_OpenInventory = 351, - OP_OpenNewTasksWindow = 352, - OP_OpenTributeMaster = 353, - OP_PDeletePetition = 354, - OP_PetBuffWindow = 355, - OP_PetCommands = 356, - OP_PetCommandState = 357, - OP_PetHoTT = 358, - OP_Petition = 359, - OP_PetitionBug = 360, - OP_PetitionCheckIn = 361, - OP_PetitionCheckout = 362, - OP_PetitionCheckout2 = 363, - OP_PetitionDelete = 364, - OP_PetitionQue = 365, - OP_PetitionRefresh = 366, - OP_PetitionResolve = 367, - OP_PetitionSearch = 368, - OP_PetitionSearchResults = 369, - OP_PetitionSearchText = 370, - OP_PetitionUnCheckout = 371, - OP_PetitionUpdate = 372, - OP_PickPocket = 373, - OP_PlayerProfile = 374, - OP_PlayerStateAdd = 375, - OP_PlayerStateRemove = 376, - OP_PlayEverquestRequest = 377, - OP_PlayEverquestResponse = 378, - OP_PlayMP3 = 379, - OP_Poll = 380, - OP_PollResponse = 381, - OP_PopupResponse = 382, - OP_PostEnterWorld = 383, - OP_PotionBelt = 384, - OP_PreLogoutReply = 385, - OP_PurchaseLeadershipAA = 386, - OP_PVPLeaderBoardDetailsReply = 387, - OP_PVPLeaderBoardDetailsRequest = 388, - OP_PVPLeaderBoardReply = 389, - OP_PVPLeaderBoardRequest = 390, - OP_PVPStats = 391, - OP_QueryResponseThing = 392, - OP_RaidInvite = 393, - OP_RaidJoin = 394, - OP_RaidUpdate = 395, - OP_RandomNameGenerator = 396, - OP_RandomReply = 397, - OP_RandomReq = 398, - OP_ReadBook = 399, - OP_RecipeAutoCombine = 400, - OP_RecipeDetails = 401, - OP_RecipeReply = 402, - OP_RecipesFavorite = 403, - OP_RecipesSearch = 404, - OP_ReclaimCrystals = 405, - OP_ReloadUI = 406, - OP_RemoveAllDoors = 407, - OP_RemoveBlockedBuffs = 408, - OP_RemoveNimbusEffect = 409, - OP_RemoveTrap = 410, - OP_Report = 411, - OP_ReqClientSpawn = 412, - OP_ReqNewZone = 413, - OP_RequestClientZoneChange = 414, - OP_RequestDuel = 415, - OP_RequestKnowledgeBase = 416, - OP_RequestTitles = 417, - OP_RespawnWindow = 418, - OP_RespondAA = 419, - OP_RestState = 420, - OP_Rewind = 421, - OP_RezzAnswer = 422, - OP_RezzComplete = 423, - OP_RezzRequest = 424, - OP_Sacrifice = 425, - OP_SafeFallSuccess = 426, - OP_SafePoint = 427, - OP_Save = 428, - OP_SaveOnZoneReq = 429, - OP_SelectTribute = 430, - OP_SendAAStats = 431, - OP_SendAATable = 432, - OP_SendCharInfo = 433, - OP_SendExpZonein = 434, - OP_SendFindableNPCs = 435, - OP_SendGuildTributes = 436, - OP_SendLoginInfo = 437, - OP_SendMaxCharacters = 438, - OP_SendMembership = 439, - OP_SendMembershipDetails = 440, - OP_SendSystemStats = 441, - OP_SendTitleList = 442, - OP_SendTributes = 443, - OP_SendZonepoints = 444, - OP_SenseHeading = 445, - OP_SenseTraps = 446, - OP_ServerListRequest = 447, - OP_ServerListResponse = 448, - OP_SessionReady = 449, - OP_SetChatServer = 450, - OP_SetChatServer2 = 451, - OP_SetGroupTarget = 452, - OP_SetGuildMOTD = 453, - OP_SetGuildRank = 454, - OP_SetRunMode = 455, - OP_SetServerFilter = 456, - OP_SetStartCity = 457, - OP_SetTitle = 458, - OP_SetTitleReply = 459, - OP_Shielding = 460, - OP_ShopDelItem = 461, - OP_ShopEnd = 462, - OP_ShopEndConfirm = 463, - OP_ShopItem = 464, - OP_ShopPlayerBuy = 465, - OP_ShopPlayerSell = 466, - OP_ShopRequest = 467, - OP_SimpleMessage = 468, - OP_SkillUpdate = 469, - OP_Sneak = 470, - OP_Some3ByteHPUpdate = 471, - OP_Some6ByteHPUpdate = 472, - OP_SomeItemPacketMaybe = 473, - OP_Sound = 474, - OP_SpawnAppearance = 475, - OP_SpawnDoor = 476, - OP_SpawnPositionUpdate = 477, - OP_SpecialMesg = 478, - OP_SpellEffect = 479, - OP_Split = 480, - OP_Stamina = 481, - OP_Stun = 482, - OP_Surname = 483, - OP_SwapSpell = 484, - OP_TargetBuffs = 485, - OP_TargetCommand = 486, - OP_TargetHoTT = 487, - OP_TargetMouse = 488, - OP_TargetReject = 489, - OP_TaskActivity = 490, - OP_TaskActivityComplete = 491, - OP_TaskDescription = 492, - OP_TaskHistoryReply = 493, - OP_TaskHistoryRequest = 494, - OP_TaskMemberList = 495, - OP_Taunt = 496, - OP_TestBuff = 497, - OP_TGB = 498, - OP_TimeOfDay = 499, - OP_Track = 500, - OP_TrackTarget = 501, - OP_TrackUnknown = 502, - OP_TradeAcceptClick = 503, - OP_TradeBusy = 504, - OP_TradeCoins = 505, - OP_TradeMoneyUpdate = 506, - OP_Trader = 507, - OP_TraderBuy = 508, - OP_TraderDelItem = 509, - OP_TradeRequest = 510, - OP_TradeRequestAck = 511, - OP_TraderItemUpdate = 512, - OP_TraderShop = 513, - OP_TradeSkillCombine = 514, - OP_Translocate = 515, - OP_TributeInfo = 516, - OP_TributeItem = 517, - OP_TributeMoney = 518, - OP_TributeNPC = 519, - OP_TributePointUpdate = 520, - OP_TributeTimer = 521, - OP_TributeToggle = 522, - OP_TributeUpdate = 523, - OP_Untargetable = 524, - OP_UpdateAA = 525, - OP_UpdateAura = 526, - OP_UpdateLeadershipAA = 527, - OP_VetClaimReply = 528, - OP_VetClaimRequest = 529, - OP_VetRewardsAvaliable = 530, - OP_VoiceMacroIn = 531, - OP_VoiceMacroOut = 532, - OP_WeaponEquip1 = 533, - OP_WearChange = 534, - OP_Weather = 535, - OP_Weblink = 536, - OP_WhoAllRequest = 537, - OP_WhoAllResponse = 538, - OP_World_Client_CRC1 = 539, - OP_World_Client_CRC2 = 540, - OP_WorldClientReady = 541, - OP_WorldComplete = 542, - OP_WorldLogout = 543, - OP_WorldObjectsSent = 544, - OP_WorldUnknown001 = 545, - OP_XTargetAutoAddHaters = 546, - OP_XTargetOpen = 547, - OP_XTargetOpenResponse = 548, - OP_XTargetRequest = 549, - OP_XTargetResponse = 550, - OP_YellForHelp = 551, - OP_ZoneChange = 552, - OP_ZoneComplete = 553, - OP_ZoneEntry = 554, - OP_ZoneGuildList = 555, - OP_ZoneInUnknown = 556, - OP_ZonePlayerToBind = 557, - OP_ZoneServerInfo = 558, - OP_ZoneServerReady = 559, - OP_ZoneSpawns = 560, - OP_ZoneUnavail = 561, - OP_ResetAA = 562, - OP_Buddy = 563, - OP_ChannelAnnounceJoin = 564, - OP_ChannelAnnounceLeave = 565, - OP_Ignore = 566, - OP_Mail = 567, - OP_MailboxChange = 568, - OP_MailDeliveryStatus = 569, - OP_MailHeader = 570, - OP_MailHeaderCount = 571, - OP_MailLogin = 572, - OP_MailNew = 573, - OP_MailSendBody = 574, - OpCode_INT_MIN_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32min, - OpCode_INT_MAX_SENTINEL_DO_NOT_USE_ = ::google::protobuf::kint32max -}; -bool OpCode_IsValid(int value); -const OpCode OpCode_MIN = OP_Unknown; -const OpCode OpCode_MAX = OP_MailSendBody; -const int OpCode_ARRAYSIZE = OpCode_MAX + 1; - -const ::google::protobuf::EnumDescriptor* OpCode_descriptor(); -inline const ::std::string& OpCode_Name(OpCode value) { - return ::google::protobuf::internal::NameOfEnum( - OpCode_descriptor(), value); -} -inline bool OpCode_Parse( - const ::std::string& name, OpCode* value) { - return ::google::protobuf::internal::ParseNamedEnum( - OpCode_descriptor(), name, value); -} -// =================================================================== - -class ChannelMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.ChannelMessage) */ { - public: - ChannelMessage(); - virtual ~ChannelMessage(); - - ChannelMessage(const ChannelMessage& from); - - inline ChannelMessage& operator=(const ChannelMessage& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - ChannelMessage(ChannelMessage&& from) noexcept - : ChannelMessage() { - *this = ::std::move(from); - } - - inline ChannelMessage& operator=(ChannelMessage&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const ChannelMessage& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const ChannelMessage* internal_default_instance() { - return reinterpret_cast( - &_ChannelMessage_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 0; - - void Swap(ChannelMessage* other); - friend void swap(ChannelMessage& a, ChannelMessage& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline ChannelMessage* New() const PROTOBUF_FINAL { return New(NULL); } - - ChannelMessage* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const ChannelMessage& from); - void MergeFrom(const ChannelMessage& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(ChannelMessage* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // string from = 3; - void clear_from(); - static const int kFromFieldNumber = 3; - const ::std::string& from() const; - void set_from(const ::std::string& value); - #if LANG_CXX11 - void set_from(::std::string&& value); - #endif - void set_from(const char* value); - void set_from(const char* value, size_t size); - ::std::string* mutable_from(); - ::std::string* release_from(); - void set_allocated_from(::std::string* from); - - // string to = 4; - void clear_to(); - static const int kToFieldNumber = 4; - const ::std::string& to() const; - void set_to(const ::std::string& value); - #if LANG_CXX11 - void set_to(::std::string&& value); - #endif - void set_to(const char* value); - void set_to(const char* value, size_t size); - ::std::string* mutable_to(); - ::std::string* release_to(); - void set_allocated_to(::std::string* to); - - // string message = 5; - void clear_message(); - static const int kMessageFieldNumber = 5; - const ::std::string& message() const; - void set_message(const ::std::string& value); - #if LANG_CXX11 - void set_message(::std::string&& value); - #endif - void set_message(const char* value); - void set_message(const char* value, size_t size); - ::std::string* mutable_message(); - ::std::string* release_message(); - void set_allocated_message(::std::string* message); - - // string deliverto = 7; - void clear_deliverto(); - static const int kDelivertoFieldNumber = 7; - const ::std::string& deliverto() const; - void set_deliverto(const ::std::string& value); - #if LANG_CXX11 - void set_deliverto(::std::string&& value); - #endif - void set_deliverto(const char* value); - void set_deliverto(const char* value, size_t size); - ::std::string* mutable_deliverto(); - ::std::string* release_deliverto(); - void set_allocated_deliverto(::std::string* deliverto); - - // int32 chan_num = 1; - void clear_chan_num(); - static const int kChanNumFieldNumber = 1; - ::google::protobuf::int32 chan_num() const; - void set_chan_num(::google::protobuf::int32 value); - - // int32 language = 2; - void clear_language(); - static const int kLanguageFieldNumber = 2; - ::google::protobuf::int32 language() const; - void set_language(::google::protobuf::int32 value); - - // int32 guilddbid = 6; - void clear_guilddbid(); - static const int kGuilddbidFieldNumber = 6; - ::google::protobuf::int32 guilddbid() const; - void set_guilddbid(::google::protobuf::int32 value); - - // int32 type = 8; - void clear_type(); - static const int kTypeFieldNumber = 8; - ::google::protobuf::int32 type() const; - void set_type(::google::protobuf::int32 value); - - // int32 minstatus = 9; - void clear_minstatus(); - static const int kMinstatusFieldNumber = 9; - ::google::protobuf::int32 minstatus() const; - void set_minstatus(::google::protobuf::int32 value); - - // int32 fromadmin = 10; - void clear_fromadmin(); - static const int kFromadminFieldNumber = 10; - ::google::protobuf::int32 fromadmin() const; - void set_fromadmin(::google::protobuf::int32 value); - - // bool noreply = 11; - void clear_noreply(); - static const int kNoreplyFieldNumber = 11; - bool noreply() const; - void set_noreply(bool value); - - // bool is_emote = 12; - void clear_is_emote(); - static const int kIsEmoteFieldNumber = 12; - bool is_emote() const; - void set_is_emote(bool value); - - // int32 queued = 13; - void clear_queued(); - static const int kQueuedFieldNumber = 13; - ::google::protobuf::int32 queued() const; - void set_queued(::google::protobuf::int32 value); - - // int32 zone_id = 14; - void clear_zone_id(); - static const int kZoneIdFieldNumber = 14; - ::google::protobuf::int32 zone_id() const; - void set_zone_id(::google::protobuf::int32 value); - - // @@protoc_insertion_point(class_scope:eqproto.ChannelMessage) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr from_; - ::google::protobuf::internal::ArenaStringPtr to_; - ::google::protobuf::internal::ArenaStringPtr message_; - ::google::protobuf::internal::ArenaStringPtr deliverto_; - ::google::protobuf::int32 chan_num_; - ::google::protobuf::int32 language_; - ::google::protobuf::int32 guilddbid_; - ::google::protobuf::int32 type_; - ::google::protobuf::int32 minstatus_; - ::google::protobuf::int32 fromadmin_; - bool noreply_; - bool is_emote_; - ::google::protobuf::int32 queued_; - ::google::protobuf::int32 zone_id_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsChannelMessageImpl(); -}; -// ------------------------------------------------------------------- - -class CommandMessage : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.CommandMessage) */ { - public: - CommandMessage(); - virtual ~CommandMessage(); - - CommandMessage(const CommandMessage& from); - - inline CommandMessage& operator=(const CommandMessage& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - CommandMessage(CommandMessage&& from) noexcept - : CommandMessage() { - *this = ::std::move(from); - } - - inline CommandMessage& operator=(CommandMessage&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const CommandMessage& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const CommandMessage* internal_default_instance() { - return reinterpret_cast( - &_CommandMessage_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 1; - - void Swap(CommandMessage* other); - friend void swap(CommandMessage& a, CommandMessage& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline CommandMessage* New() const PROTOBUF_FINAL { return New(NULL); } - - CommandMessage* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const CommandMessage& from); - void MergeFrom(const CommandMessage& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(CommandMessage* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // repeated string params = 3; - int params_size() const; - void clear_params(); - static const int kParamsFieldNumber = 3; - const ::std::string& params(int index) const; - ::std::string* mutable_params(int index); - void set_params(int index, const ::std::string& value); - #if LANG_CXX11 - void set_params(int index, ::std::string&& value); - #endif - void set_params(int index, const char* value); - void set_params(int index, const char* value, size_t size); - ::std::string* add_params(); - void add_params(const ::std::string& value); - #if LANG_CXX11 - void add_params(::std::string&& value); - #endif - void add_params(const char* value); - void add_params(const char* value, size_t size); - const ::google::protobuf::RepeatedPtrField< ::std::string>& params() const; - ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_params(); - - // string author = 1; - void clear_author(); - static const int kAuthorFieldNumber = 1; - const ::std::string& author() const; - void set_author(const ::std::string& value); - #if LANG_CXX11 - void set_author(::std::string&& value); - #endif - void set_author(const char* value); - void set_author(const char* value, size_t size); - ::std::string* mutable_author(); - ::std::string* release_author(); - void set_allocated_author(::std::string* author); - - // string command = 2; - void clear_command(); - static const int kCommandFieldNumber = 2; - const ::std::string& command() const; - void set_command(const ::std::string& value); - #if LANG_CXX11 - void set_command(::std::string&& value); - #endif - void set_command(const char* value); - void set_command(const char* value, size_t size); - ::std::string* mutable_command(); - ::std::string* release_command(); - void set_allocated_command(::std::string* command); - - // string result = 4; - void clear_result(); - static const int kResultFieldNumber = 4; - const ::std::string& result() const; - void set_result(const ::std::string& value); - #if LANG_CXX11 - void set_result(::std::string&& value); - #endif - void set_result(const char* value); - void set_result(const char* value, size_t size); - ::std::string* mutable_result(); - ::std::string* release_result(); - void set_allocated_result(::std::string* result); - - // bytes payload = 5; - void clear_payload(); - static const int kPayloadFieldNumber = 5; - const ::std::string& payload() const; - void set_payload(const ::std::string& value); - #if LANG_CXX11 - void set_payload(::std::string&& value); - #endif - void set_payload(const char* value); - void set_payload(const void* value, size_t size); - ::std::string* mutable_payload(); - ::std::string* release_payload(); - void set_allocated_payload(::std::string* payload); - - // @@protoc_insertion_point(class_scope:eqproto.CommandMessage) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::RepeatedPtrField< ::std::string> params_; - ::google::protobuf::internal::ArenaStringPtr author_; - ::google::protobuf::internal::ArenaStringPtr command_; - ::google::protobuf::internal::ArenaStringPtr result_; - ::google::protobuf::internal::ArenaStringPtr payload_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsCommandMessageImpl(); -}; -// ------------------------------------------------------------------- - -class DailyGain : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.DailyGain) */ { - public: - DailyGain(); - virtual ~DailyGain(); - - DailyGain(const DailyGain& from); - - inline DailyGain& operator=(const DailyGain& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - DailyGain(DailyGain&& from) noexcept - : DailyGain() { - *this = ::std::move(from); - } - - inline DailyGain& operator=(DailyGain&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const DailyGain& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const DailyGain* internal_default_instance() { - return reinterpret_cast( - &_DailyGain_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 2; - - void Swap(DailyGain* other); - friend void swap(DailyGain& a, DailyGain& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline DailyGain* New() const PROTOBUF_FINAL { return New(NULL); } - - DailyGain* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const DailyGain& from); - void MergeFrom(const DailyGain& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(DailyGain* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // string identity = 6; - void clear_identity(); - static const int kIdentityFieldNumber = 6; - const ::std::string& identity() const; - void set_identity(const ::std::string& value); - #if LANG_CXX11 - void set_identity(::std::string&& value); - #endif - void set_identity(const char* value); - void set_identity(const char* value, size_t size); - ::std::string* mutable_identity(); - ::std::string* release_identity(); - void set_allocated_identity(::std::string* identity); - - // int32 account_id = 1; - void clear_account_id(); - static const int kAccountIdFieldNumber = 1; - ::google::protobuf::int32 account_id() const; - void set_account_id(::google::protobuf::int32 value); - - // int32 character_id = 2; - void clear_character_id(); - static const int kCharacterIdFieldNumber = 2; - ::google::protobuf::int32 character_id() const; - void set_character_id(::google::protobuf::int32 value); - - // int32 levels_gained = 3; - void clear_levels_gained(); - static const int kLevelsGainedFieldNumber = 3; - ::google::protobuf::int32 levels_gained() const; - void set_levels_gained(::google::protobuf::int32 value); - - // int32 experience_gained = 4; - void clear_experience_gained(); - static const int kExperienceGainedFieldNumber = 4; - ::google::protobuf::int32 experience_gained() const; - void set_experience_gained(::google::protobuf::int32 value); - - // int32 money_earned = 5; - void clear_money_earned(); - static const int kMoneyEarnedFieldNumber = 5; - ::google::protobuf::int32 money_earned() const; - void set_money_earned(::google::protobuf::int32 value); - - // @@protoc_insertion_point(class_scope:eqproto.DailyGain) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr identity_; - ::google::protobuf::int32 account_id_; - ::google::protobuf::int32 character_id_; - ::google::protobuf::int32 levels_gained_; - ::google::protobuf::int32 experience_gained_; - ::google::protobuf::int32 money_earned_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsDailyGainImpl(); -}; -// ------------------------------------------------------------------- - -class Entity : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Entity) */ { - public: - Entity(); - virtual ~Entity(); - - Entity(const Entity& from); - - inline Entity& operator=(const Entity& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Entity(Entity&& from) noexcept - : Entity() { - *this = ::std::move(from); - } - - inline Entity& operator=(Entity&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Entity& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Entity* internal_default_instance() { - return reinterpret_cast( - &_Entity_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 3; - - void Swap(Entity* other); - friend void swap(Entity& a, Entity& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Entity* New() const PROTOBUF_FINAL { return New(NULL); } - - Entity* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Entity& from); - void MergeFrom(const Entity& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Entity* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // string name = 2; - void clear_name(); - static const int kNameFieldNumber = 2; - const ::std::string& name() const; - void set_name(const ::std::string& value); - #if LANG_CXX11 - void set_name(::std::string&& value); - #endif - void set_name(const char* value); - void set_name(const char* value, size_t size); - ::std::string* mutable_name(); - ::std::string* release_name(); - void set_allocated_name(::std::string* name); - - // .eqproto.Position position = 6; - bool has_position() const; - void clear_position(); - static const int kPositionFieldNumber = 6; - const ::eqproto::Position& position() const; - ::eqproto::Position* release_position(); - ::eqproto::Position* mutable_position(); - void set_allocated_position(::eqproto::Position* position); - - // int32 id = 1; - void clear_id(); - static const int kIdFieldNumber = 1; - ::google::protobuf::int32 id() const; - void set_id(::google::protobuf::int32 value); - - // int32 type = 3; - void clear_type(); - static const int kTypeFieldNumber = 3; - ::google::protobuf::int32 type() const; - void set_type(::google::protobuf::int32 value); - - // int32 hp = 4; - void clear_hp(); - static const int kHpFieldNumber = 4; - ::google::protobuf::int32 hp() const; - void set_hp(::google::protobuf::int32 value); - - // int32 level = 5; - void clear_level(); - static const int kLevelFieldNumber = 5; - ::google::protobuf::int32 level() const; - void set_level(::google::protobuf::int32 value); - - // int32 race = 7; - void clear_race(); - static const int kRaceFieldNumber = 7; - ::google::protobuf::int32 race() const; - void set_race(::google::protobuf::int32 value); - - // int32 class = 8; - void clear_class_(); - static const int kClassFieldNumber = 8; - ::google::protobuf::int32 class_() const; - void set_class_(::google::protobuf::int32 value); - - // @@protoc_insertion_point(class_scope:eqproto.Entity) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr name_; - ::eqproto::Position* position_; - ::google::protobuf::int32 id_; - ::google::protobuf::int32 type_; - ::google::protobuf::int32 hp_; - ::google::protobuf::int32 level_; - ::google::protobuf::int32 race_; - ::google::protobuf::int32 class__; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsEntityImpl(); -}; -// ------------------------------------------------------------------- - -class Entities : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Entities) */ { - public: - Entities(); - virtual ~Entities(); - - Entities(const Entities& from); - - inline Entities& operator=(const Entities& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Entities(Entities&& from) noexcept - : Entities() { - *this = ::std::move(from); - } - - inline Entities& operator=(Entities&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Entities& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Entities* internal_default_instance() { - return reinterpret_cast( - &_Entities_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 4; - - void Swap(Entities* other); - friend void swap(Entities& a, Entities& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Entities* New() const PROTOBUF_FINAL { return New(NULL); } - - Entities* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Entities& from); - void MergeFrom(const Entities& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Entities* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // repeated .eqproto.Entity entities = 1; - int entities_size() const; - void clear_entities(); - static const int kEntitiesFieldNumber = 1; - const ::eqproto::Entity& entities(int index) const; - ::eqproto::Entity* mutable_entities(int index); - ::eqproto::Entity* add_entities(); - ::google::protobuf::RepeatedPtrField< ::eqproto::Entity >* - mutable_entities(); - const ::google::protobuf::RepeatedPtrField< ::eqproto::Entity >& - entities() const; - - // @@protoc_insertion_point(class_scope:eqproto.Entities) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::RepeatedPtrField< ::eqproto::Entity > entities_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsEntitiesImpl(); -}; -// ------------------------------------------------------------------- - -class Position : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Position) */ { - public: - Position(); - virtual ~Position(); - - Position(const Position& from); - - inline Position& operator=(const Position& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Position(Position&& from) noexcept - : Position() { - *this = ::std::move(from); - } - - inline Position& operator=(Position&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Position& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Position* internal_default_instance() { - return reinterpret_cast( - &_Position_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 5; - - void Swap(Position* other); - friend void swap(Position& a, Position& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Position* New() const PROTOBUF_FINAL { return New(NULL); } - - Position* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Position& from); - void MergeFrom(const Position& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Position* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // float x = 1; - void clear_x(); - static const int kXFieldNumber = 1; - float x() const; - void set_x(float value); - - // float y = 2; - void clear_y(); - static const int kYFieldNumber = 2; - float y() const; - void set_y(float value); - - // float z = 3; - void clear_z(); - static const int kZFieldNumber = 3; - float z() const; - void set_z(float value); - - // float h = 4; - void clear_h(); - static const int kHFieldNumber = 4; - float h() const; - void set_h(float value); - - // @@protoc_insertion_point(class_scope:eqproto.Position) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - float x_; - float y_; - float z_; - float h_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsPositionImpl(); -}; -// ------------------------------------------------------------------- - -class TextureProfile : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.TextureProfile) */ { - public: - TextureProfile(); - virtual ~TextureProfile(); - - TextureProfile(const TextureProfile& from); - - inline TextureProfile& operator=(const TextureProfile& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - TextureProfile(TextureProfile&& from) noexcept - : TextureProfile() { - *this = ::std::move(from); - } - - inline TextureProfile& operator=(TextureProfile&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const TextureProfile& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TextureProfile* internal_default_instance() { - return reinterpret_cast( - &_TextureProfile_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 6; - - void Swap(TextureProfile* other); - friend void swap(TextureProfile& a, TextureProfile& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline TextureProfile* New() const PROTOBUF_FINAL { return New(NULL); } - - TextureProfile* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const TextureProfile& from); - void MergeFrom(const TextureProfile& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(TextureProfile* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // .eqproto.Texture Head = 1; - bool has_head() const; - void clear_head(); - static const int kHeadFieldNumber = 1; - const ::eqproto::Texture& head() const; - ::eqproto::Texture* release_head(); - ::eqproto::Texture* mutable_head(); - void set_allocated_head(::eqproto::Texture* head); - - // .eqproto.Texture Chest = 2; - bool has_chest() const; - void clear_chest(); - static const int kChestFieldNumber = 2; - const ::eqproto::Texture& chest() const; - ::eqproto::Texture* release_chest(); - ::eqproto::Texture* mutable_chest(); - void set_allocated_chest(::eqproto::Texture* chest); - - // .eqproto.Texture Arms = 3; - bool has_arms() const; - void clear_arms(); - static const int kArmsFieldNumber = 3; - const ::eqproto::Texture& arms() const; - ::eqproto::Texture* release_arms(); - ::eqproto::Texture* mutable_arms(); - void set_allocated_arms(::eqproto::Texture* arms); - - // .eqproto.Texture Wrist = 4; - bool has_wrist() const; - void clear_wrist(); - static const int kWristFieldNumber = 4; - const ::eqproto::Texture& wrist() const; - ::eqproto::Texture* release_wrist(); - ::eqproto::Texture* mutable_wrist(); - void set_allocated_wrist(::eqproto::Texture* wrist); - - // .eqproto.Texture Hands = 5; - bool has_hands() const; - void clear_hands(); - static const int kHandsFieldNumber = 5; - const ::eqproto::Texture& hands() const; - ::eqproto::Texture* release_hands(); - ::eqproto::Texture* mutable_hands(); - void set_allocated_hands(::eqproto::Texture* hands); - - // .eqproto.Texture Legs = 6; - bool has_legs() const; - void clear_legs(); - static const int kLegsFieldNumber = 6; - const ::eqproto::Texture& legs() const; - ::eqproto::Texture* release_legs(); - ::eqproto::Texture* mutable_legs(); - void set_allocated_legs(::eqproto::Texture* legs); - - // .eqproto.Texture Feet = 7; - bool has_feet() const; - void clear_feet(); - static const int kFeetFieldNumber = 7; - const ::eqproto::Texture& feet() const; - ::eqproto::Texture* release_feet(); - ::eqproto::Texture* mutable_feet(); - void set_allocated_feet(::eqproto::Texture* feet); - - // .eqproto.Texture Primary = 8; - bool has_primary() const; - void clear_primary(); - static const int kPrimaryFieldNumber = 8; - const ::eqproto::Texture& primary() const; - ::eqproto::Texture* release_primary(); - ::eqproto::Texture* mutable_primary(); - void set_allocated_primary(::eqproto::Texture* primary); - - // .eqproto.Texture Secondary = 9; - bool has_secondary() const; - void clear_secondary(); - static const int kSecondaryFieldNumber = 9; - const ::eqproto::Texture& secondary() const; - ::eqproto::Texture* release_secondary(); - ::eqproto::Texture* mutable_secondary(); - void set_allocated_secondary(::eqproto::Texture* secondary); - - // @@protoc_insertion_point(class_scope:eqproto.TextureProfile) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::eqproto::Texture* head_; - ::eqproto::Texture* chest_; - ::eqproto::Texture* arms_; - ::eqproto::Texture* wrist_; - ::eqproto::Texture* hands_; - ::eqproto::Texture* legs_; - ::eqproto::Texture* feet_; - ::eqproto::Texture* primary_; - ::eqproto::Texture* secondary_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsTextureProfileImpl(); -}; -// ------------------------------------------------------------------- - -class Texture : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Texture) */ { - public: - Texture(); - virtual ~Texture(); - - Texture(const Texture& from); - - inline Texture& operator=(const Texture& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Texture(Texture&& from) noexcept - : Texture() { - *this = ::std::move(from); - } - - inline Texture& operator=(Texture&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Texture& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Texture* internal_default_instance() { - return reinterpret_cast( - &_Texture_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 7; - - void Swap(Texture* other); - friend void swap(Texture& a, Texture& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Texture* New() const PROTOBUF_FINAL { return New(NULL); } - - Texture* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Texture& from); - void MergeFrom(const Texture& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Texture* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 material = 1; - void clear_material(); - static const int kMaterialFieldNumber = 1; - ::google::protobuf::uint32 material() const; - void set_material(::google::protobuf::uint32 value); - - // uint32 unknown1 = 2; - void clear_unknown1(); - static const int kUnknown1FieldNumber = 2; - ::google::protobuf::uint32 unknown1() const; - void set_unknown1(::google::protobuf::uint32 value); - - // uint32 EliteModel = 3; - void clear_elitemodel(); - static const int kEliteModelFieldNumber = 3; - ::google::protobuf::uint32 elitemodel() const; - void set_elitemodel(::google::protobuf::uint32 value); - - // uint32 HerosForgeModel = 4; - void clear_herosforgemodel(); - static const int kHerosForgeModelFieldNumber = 4; - ::google::protobuf::uint32 herosforgemodel() const; - void set_herosforgemodel(::google::protobuf::uint32 value); - - // uint32 Unknown2 = 5; - void clear_unknown2(); - static const int kUnknown2FieldNumber = 5; - ::google::protobuf::uint32 unknown2() const; - void set_unknown2(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.Texture) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 material_; - ::google::protobuf::uint32 unknown1_; - ::google::protobuf::uint32 elitemodel_; - ::google::protobuf::uint32 herosforgemodel_; - ::google::protobuf::uint32 unknown2_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsTextureImpl(); -}; -// ------------------------------------------------------------------- - -class TintProfile : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.TintProfile) */ { - public: - TintProfile(); - virtual ~TintProfile(); - - TintProfile(const TintProfile& from); - - inline TintProfile& operator=(const TintProfile& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - TintProfile(TintProfile&& from) noexcept - : TintProfile() { - *this = ::std::move(from); - } - - inline TintProfile& operator=(TintProfile&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const TintProfile& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const TintProfile* internal_default_instance() { - return reinterpret_cast( - &_TintProfile_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 8; - - void Swap(TintProfile* other); - friend void swap(TintProfile& a, TintProfile& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline TintProfile* New() const PROTOBUF_FINAL { return New(NULL); } - - TintProfile* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const TintProfile& from); - void MergeFrom(const TintProfile& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(TintProfile* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // .eqproto.Tint Head = 1; - bool has_head() const; - void clear_head(); - static const int kHeadFieldNumber = 1; - const ::eqproto::Tint& head() const; - ::eqproto::Tint* release_head(); - ::eqproto::Tint* mutable_head(); - void set_allocated_head(::eqproto::Tint* head); - - // .eqproto.Tint Chest = 2; - bool has_chest() const; - void clear_chest(); - static const int kChestFieldNumber = 2; - const ::eqproto::Tint& chest() const; - ::eqproto::Tint* release_chest(); - ::eqproto::Tint* mutable_chest(); - void set_allocated_chest(::eqproto::Tint* chest); - - // .eqproto.Tint Arms = 3; - bool has_arms() const; - void clear_arms(); - static const int kArmsFieldNumber = 3; - const ::eqproto::Tint& arms() const; - ::eqproto::Tint* release_arms(); - ::eqproto::Tint* mutable_arms(); - void set_allocated_arms(::eqproto::Tint* arms); - - // .eqproto.Tint Wrist = 4; - bool has_wrist() const; - void clear_wrist(); - static const int kWristFieldNumber = 4; - const ::eqproto::Tint& wrist() const; - ::eqproto::Tint* release_wrist(); - ::eqproto::Tint* mutable_wrist(); - void set_allocated_wrist(::eqproto::Tint* wrist); - - // .eqproto.Tint Hands = 5; - bool has_hands() const; - void clear_hands(); - static const int kHandsFieldNumber = 5; - const ::eqproto::Tint& hands() const; - ::eqproto::Tint* release_hands(); - ::eqproto::Tint* mutable_hands(); - void set_allocated_hands(::eqproto::Tint* hands); - - // .eqproto.Tint Legs = 6; - bool has_legs() const; - void clear_legs(); - static const int kLegsFieldNumber = 6; - const ::eqproto::Tint& legs() const; - ::eqproto::Tint* release_legs(); - ::eqproto::Tint* mutable_legs(); - void set_allocated_legs(::eqproto::Tint* legs); - - // .eqproto.Tint Feet = 7; - bool has_feet() const; - void clear_feet(); - static const int kFeetFieldNumber = 7; - const ::eqproto::Tint& feet() const; - ::eqproto::Tint* release_feet(); - ::eqproto::Tint* mutable_feet(); - void set_allocated_feet(::eqproto::Tint* feet); - - // .eqproto.Tint Primary = 8; - bool has_primary() const; - void clear_primary(); - static const int kPrimaryFieldNumber = 8; - const ::eqproto::Tint& primary() const; - ::eqproto::Tint* release_primary(); - ::eqproto::Tint* mutable_primary(); - void set_allocated_primary(::eqproto::Tint* primary); - - // .eqproto.Tint Secondary = 9; - bool has_secondary() const; - void clear_secondary(); - static const int kSecondaryFieldNumber = 9; - const ::eqproto::Tint& secondary() const; - ::eqproto::Tint* release_secondary(); - ::eqproto::Tint* mutable_secondary(); - void set_allocated_secondary(::eqproto::Tint* secondary); - - // @@protoc_insertion_point(class_scope:eqproto.TintProfile) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::eqproto::Tint* head_; - ::eqproto::Tint* chest_; - ::eqproto::Tint* arms_; - ::eqproto::Tint* wrist_; - ::eqproto::Tint* hands_; - ::eqproto::Tint* legs_; - ::eqproto::Tint* feet_; - ::eqproto::Tint* primary_; - ::eqproto::Tint* secondary_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsTintProfileImpl(); -}; -// ------------------------------------------------------------------- - -class Tint : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Tint) */ { - public: - Tint(); - virtual ~Tint(); - - Tint(const Tint& from); - - inline Tint& operator=(const Tint& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Tint(Tint&& from) noexcept - : Tint() { - *this = ::std::move(from); - } - - inline Tint& operator=(Tint&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Tint& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Tint* internal_default_instance() { - return reinterpret_cast( - &_Tint_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 9; - - void Swap(Tint* other); - friend void swap(Tint& a, Tint& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Tint* New() const PROTOBUF_FINAL { return New(NULL); } - - Tint* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Tint& from); - void MergeFrom(const Tint& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Tint* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 Blue = 1; - void clear_blue(); - static const int kBlueFieldNumber = 1; - ::google::protobuf::uint32 blue() const; - void set_blue(::google::protobuf::uint32 value); - - // uint32 Green = 2; - void clear_green(); - static const int kGreenFieldNumber = 2; - ::google::protobuf::uint32 green() const; - void set_green(::google::protobuf::uint32 value); - - // uint32 Red = 3; - void clear_red(); - static const int kRedFieldNumber = 3; - ::google::protobuf::uint32 red() const; - void set_red(::google::protobuf::uint32 value); - - // uint32 UseTint = 4; - void clear_usetint(); - static const int kUseTintFieldNumber = 4; - ::google::protobuf::uint32 usetint() const; - void set_usetint(::google::protobuf::uint32 value); - - // uint32 Color = 5; - void clear_color(); - static const int kColorFieldNumber = 5; - ::google::protobuf::uint32 color() const; - void set_color(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.Tint) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 blue_; - ::google::protobuf::uint32 green_; - ::google::protobuf::uint32 red_; - ::google::protobuf::uint32 usetint_; - ::google::protobuf::uint32 color_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsTintImpl(); -}; -// ------------------------------------------------------------------- - -class Event : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.Event) */ { - public: - Event(); - virtual ~Event(); - - Event(const Event& from); - - inline Event& operator=(const Event& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - Event(Event&& from) noexcept - : Event() { - *this = ::std::move(from); - } - - inline Event& operator=(Event&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const Event& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const Event* internal_default_instance() { - return reinterpret_cast( - &_Event_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 10; - - void Swap(Event* other); - friend void swap(Event& a, Event& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline Event* New() const PROTOBUF_FINAL { return New(NULL); } - - Event* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const Event& from); - void MergeFrom(const Event& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(Event* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // bytes payload = 2; - void clear_payload(); - static const int kPayloadFieldNumber = 2; - const ::std::string& payload() const; - void set_payload(const ::std::string& value); - #if LANG_CXX11 - void set_payload(::std::string&& value); - #endif - void set_payload(const char* value); - void set_payload(const void* value, size_t size); - ::std::string* mutable_payload(); - ::std::string* release_payload(); - void set_allocated_payload(::std::string* payload); - - // .eqproto.OpCode op = 1; - void clear_op(); - static const int kOpFieldNumber = 1; - ::eqproto::OpCode op() const; - void set_op(::eqproto::OpCode value); - - // @@protoc_insertion_point(class_scope:eqproto.Event) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr payload_; - int op_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsEventImpl(); -}; -// ------------------------------------------------------------------- - -class DeathEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.DeathEvent) */ { - public: - DeathEvent(); - virtual ~DeathEvent(); - - DeathEvent(const DeathEvent& from); - - inline DeathEvent& operator=(const DeathEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - DeathEvent(DeathEvent&& from) noexcept - : DeathEvent() { - *this = ::std::move(from); - } - - inline DeathEvent& operator=(DeathEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const DeathEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const DeathEvent* internal_default_instance() { - return reinterpret_cast( - &_DeathEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 11; - - void Swap(DeathEvent* other); - friend void swap(DeathEvent& a, DeathEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline DeathEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - DeathEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const DeathEvent& from); - void MergeFrom(const DeathEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(DeathEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 spawn_id = 1; - void clear_spawn_id(); - static const int kSpawnIdFieldNumber = 1; - ::google::protobuf::uint32 spawn_id() const; - void set_spawn_id(::google::protobuf::uint32 value); - - // uint32 killer_id = 2; - void clear_killer_id(); - static const int kKillerIdFieldNumber = 2; - ::google::protobuf::uint32 killer_id() const; - void set_killer_id(::google::protobuf::uint32 value); - - // uint32 corpse_id = 3; - void clear_corpse_id(); - static const int kCorpseIdFieldNumber = 3; - ::google::protobuf::uint32 corpse_id() const; - void set_corpse_id(::google::protobuf::uint32 value); - - // uint32 bind_zone_id = 4; - void clear_bind_zone_id(); - static const int kBindZoneIdFieldNumber = 4; - ::google::protobuf::uint32 bind_zone_id() const; - void set_bind_zone_id(::google::protobuf::uint32 value); - - // uint32 spell_id = 5; - void clear_spell_id(); - static const int kSpellIdFieldNumber = 5; - ::google::protobuf::uint32 spell_id() const; - void set_spell_id(::google::protobuf::uint32 value); - - // uint32 attack_skill_id = 6; - void clear_attack_skill_id(); - static const int kAttackSkillIdFieldNumber = 6; - ::google::protobuf::uint32 attack_skill_id() const; - void set_attack_skill_id(::google::protobuf::uint32 value); - - // uint32 damage = 7; - void clear_damage(); - static const int kDamageFieldNumber = 7; - ::google::protobuf::uint32 damage() const; - void set_damage(::google::protobuf::uint32 value); - - // uint32 unknown028 = 8; - void clear_unknown028(); - static const int kUnknown028FieldNumber = 8; - ::google::protobuf::uint32 unknown028() const; - void set_unknown028(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.DeathEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 spawn_id_; - ::google::protobuf::uint32 killer_id_; - ::google::protobuf::uint32 corpse_id_; - ::google::protobuf::uint32 bind_zone_id_; - ::google::protobuf::uint32 spell_id_; - ::google::protobuf::uint32 attack_skill_id_; - ::google::protobuf::uint32 damage_; - ::google::protobuf::uint32 unknown028_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsDeathEventImpl(); -}; -// ------------------------------------------------------------------- - -class DamageEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.DamageEvent) */ { - public: - DamageEvent(); - virtual ~DamageEvent(); - - DamageEvent(const DamageEvent& from); - - inline DamageEvent& operator=(const DamageEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - DamageEvent(DamageEvent&& from) noexcept - : DamageEvent() { - *this = ::std::move(from); - } - - inline DamageEvent& operator=(DamageEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const DamageEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const DamageEvent* internal_default_instance() { - return reinterpret_cast( - &_DamageEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 12; - - void Swap(DamageEvent* other); - friend void swap(DamageEvent& a, DamageEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline DamageEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - DamageEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const DamageEvent& from); - void MergeFrom(const DamageEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(DamageEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 target = 1; - void clear_target(); - static const int kTargetFieldNumber = 1; - ::google::protobuf::uint32 target() const; - void set_target(::google::protobuf::uint32 value); - - // uint32 source = 2; - void clear_source(); - static const int kSourceFieldNumber = 2; - ::google::protobuf::uint32 source() const; - void set_source(::google::protobuf::uint32 value); - - // uint32 type = 3; - void clear_type(); - static const int kTypeFieldNumber = 3; - ::google::protobuf::uint32 type() const; - void set_type(::google::protobuf::uint32 value); - - // uint32 spellid = 4; - void clear_spellid(); - static const int kSpellidFieldNumber = 4; - ::google::protobuf::uint32 spellid() const; - void set_spellid(::google::protobuf::uint32 value); - - // uint32 damage = 5; - void clear_damage(); - static const int kDamageFieldNumber = 5; - ::google::protobuf::uint32 damage() const; - void set_damage(::google::protobuf::uint32 value); - - // float force = 6; - void clear_force(); - static const int kForceFieldNumber = 6; - float force() const; - void set_force(float value); - - // float meleepush_xy = 7; - void clear_meleepush_xy(); - static const int kMeleepushXyFieldNumber = 7; - float meleepush_xy() const; - void set_meleepush_xy(float value); - - // float meleepush_z = 8; - void clear_meleepush_z(); - static const int kMeleepushZFieldNumber = 8; - float meleepush_z() const; - void set_meleepush_z(float value); - - // @@protoc_insertion_point(class_scope:eqproto.DamageEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 target_; - ::google::protobuf::uint32 source_; - ::google::protobuf::uint32 type_; - ::google::protobuf::uint32 spellid_; - ::google::protobuf::uint32 damage_; - float force_; - float meleepush_xy_; - float meleepush_z_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsDamageEventImpl(); -}; -// ------------------------------------------------------------------- - -class EntityEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.EntityEvent) */ { - public: - EntityEvent(); - virtual ~EntityEvent(); - - EntityEvent(const EntityEvent& from); - - inline EntityEvent& operator=(const EntityEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - EntityEvent(EntityEvent&& from) noexcept - : EntityEvent() { - *this = ::std::move(from); - } - - inline EntityEvent& operator=(EntityEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const EntityEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const EntityEvent* internal_default_instance() { - return reinterpret_cast( - &_EntityEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 13; - - void Swap(EntityEvent* other); - friend void swap(EntityEvent& a, EntityEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline EntityEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - EntityEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const EntityEvent& from); - void MergeFrom(const EntityEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(EntityEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 entity_id = 1; - void clear_entity_id(); - static const int kEntityIdFieldNumber = 1; - ::google::protobuf::uint32 entity_id() const; - void set_entity_id(::google::protobuf::uint32 value); - - // uint32 target_id = 2; - void clear_target_id(); - static const int kTargetIdFieldNumber = 2; - ::google::protobuf::uint32 target_id() const; - void set_target_id(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.EntityEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 entity_id_; - ::google::protobuf::uint32 target_id_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsEntityEventImpl(); -}; -// ------------------------------------------------------------------- - -class ChannelMessageEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.ChannelMessageEvent) */ { - public: - ChannelMessageEvent(); - virtual ~ChannelMessageEvent(); - - ChannelMessageEvent(const ChannelMessageEvent& from); - - inline ChannelMessageEvent& operator=(const ChannelMessageEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - ChannelMessageEvent(ChannelMessageEvent&& from) noexcept - : ChannelMessageEvent() { - *this = ::std::move(from); - } - - inline ChannelMessageEvent& operator=(ChannelMessageEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const ChannelMessageEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const ChannelMessageEvent* internal_default_instance() { - return reinterpret_cast( - &_ChannelMessageEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 14; - - void Swap(ChannelMessageEvent* other); - friend void swap(ChannelMessageEvent& a, ChannelMessageEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline ChannelMessageEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - ChannelMessageEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const ChannelMessageEvent& from); - void MergeFrom(const ChannelMessageEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(ChannelMessageEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // string target_name = 1; - void clear_target_name(); - static const int kTargetNameFieldNumber = 1; - const ::std::string& target_name() const; - void set_target_name(const ::std::string& value); - #if LANG_CXX11 - void set_target_name(::std::string&& value); - #endif - void set_target_name(const char* value); - void set_target_name(const char* value, size_t size); - ::std::string* mutable_target_name(); - ::std::string* release_target_name(); - void set_allocated_target_name(::std::string* target_name); - - // string sender = 2; - void clear_sender(); - static const int kSenderFieldNumber = 2; - const ::std::string& sender() const; - void set_sender(const ::std::string& value); - #if LANG_CXX11 - void set_sender(::std::string&& value); - #endif - void set_sender(const char* value); - void set_sender(const char* value, size_t size); - ::std::string* mutable_sender(); - ::std::string* release_sender(); - void set_allocated_sender(::std::string* sender); - - // string message = 7; - void clear_message(); - static const int kMessageFieldNumber = 7; - const ::std::string& message() const; - void set_message(const ::std::string& value); - #if LANG_CXX11 - void set_message(::std::string&& value); - #endif - void set_message(const char* value); - void set_message(const char* value, size_t size); - ::std::string* mutable_message(); - ::std::string* release_message(); - void set_allocated_message(::std::string* message); - - // uint32 language = 3; - void clear_language(); - static const int kLanguageFieldNumber = 3; - ::google::protobuf::uint32 language() const; - void set_language(::google::protobuf::uint32 value); - - // uint32 chan_num = 4; - void clear_chan_num(); - static const int kChanNumFieldNumber = 4; - ::google::protobuf::uint32 chan_num() const; - void set_chan_num(::google::protobuf::uint32 value); - - // uint32 cm_unknown4 = 5; - void clear_cm_unknown4(); - static const int kCmUnknown4FieldNumber = 5; - ::google::protobuf::uint32 cm_unknown4() const; - void set_cm_unknown4(::google::protobuf::uint32 value); - - // uint32 skill_in_language = 6; - void clear_skill_in_language(); - static const int kSkillInLanguageFieldNumber = 6; - ::google::protobuf::uint32 skill_in_language() const; - void set_skill_in_language(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.ChannelMessageEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr target_name_; - ::google::protobuf::internal::ArenaStringPtr sender_; - ::google::protobuf::internal::ArenaStringPtr message_; - ::google::protobuf::uint32 language_; - ::google::protobuf::uint32 chan_num_; - ::google::protobuf::uint32 cm_unknown4_; - ::google::protobuf::uint32 skill_in_language_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsChannelMessageEventImpl(); -}; -// ------------------------------------------------------------------- - -class WearChangeEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.WearChangeEvent) */ { - public: - WearChangeEvent(); - virtual ~WearChangeEvent(); - - WearChangeEvent(const WearChangeEvent& from); - - inline WearChangeEvent& operator=(const WearChangeEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - WearChangeEvent(WearChangeEvent&& from) noexcept - : WearChangeEvent() { - *this = ::std::move(from); - } - - inline WearChangeEvent& operator=(WearChangeEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const WearChangeEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const WearChangeEvent* internal_default_instance() { - return reinterpret_cast( - &_WearChangeEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 15; - - void Swap(WearChangeEvent* other); - friend void swap(WearChangeEvent& a, WearChangeEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline WearChangeEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - WearChangeEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const WearChangeEvent& from); - void MergeFrom(const WearChangeEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(WearChangeEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // .eqproto.Tint color = 7; - bool has_color() const; - void clear_color(); - static const int kColorFieldNumber = 7; - const ::eqproto::Tint& color() const; - ::eqproto::Tint* release_color(); - ::eqproto::Tint* mutable_color(); - void set_allocated_color(::eqproto::Tint* color); - - // uint32 spawn_id = 1; - void clear_spawn_id(); - static const int kSpawnIdFieldNumber = 1; - ::google::protobuf::uint32 spawn_id() const; - void set_spawn_id(::google::protobuf::uint32 value); - - // uint32 material = 2; - void clear_material(); - static const int kMaterialFieldNumber = 2; - ::google::protobuf::uint32 material() const; - void set_material(::google::protobuf::uint32 value); - - // uint32 unknown06 = 3; - void clear_unknown06(); - static const int kUnknown06FieldNumber = 3; - ::google::protobuf::uint32 unknown06() const; - void set_unknown06(::google::protobuf::uint32 value); - - // uint32 elite_material = 4; - void clear_elite_material(); - static const int kEliteMaterialFieldNumber = 4; - ::google::protobuf::uint32 elite_material() const; - void set_elite_material(::google::protobuf::uint32 value); - - // uint32 hero_forge_model = 5; - void clear_hero_forge_model(); - static const int kHeroForgeModelFieldNumber = 5; - ::google::protobuf::uint32 hero_forge_model() const; - void set_hero_forge_model(::google::protobuf::uint32 value); - - // uint32 unknown18 = 6; - void clear_unknown18(); - static const int kUnknown18FieldNumber = 6; - ::google::protobuf::uint32 unknown18() const; - void set_unknown18(::google::protobuf::uint32 value); - - // uint32 wear_slot_id = 8; - void clear_wear_slot_id(); - static const int kWearSlotIdFieldNumber = 8; - ::google::protobuf::uint32 wear_slot_id() const; - void set_wear_slot_id(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.WearChangeEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::eqproto::Tint* color_; - ::google::protobuf::uint32 spawn_id_; - ::google::protobuf::uint32 material_; - ::google::protobuf::uint32 unknown06_; - ::google::protobuf::uint32 elite_material_; - ::google::protobuf::uint32 hero_forge_model_; - ::google::protobuf::uint32 unknown18_; - ::google::protobuf::uint32 wear_slot_id_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsWearChangeEventImpl(); -}; -// ------------------------------------------------------------------- - -class DeleteSpawnEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.DeleteSpawnEvent) */ { - public: - DeleteSpawnEvent(); - virtual ~DeleteSpawnEvent(); - - DeleteSpawnEvent(const DeleteSpawnEvent& from); - - inline DeleteSpawnEvent& operator=(const DeleteSpawnEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - DeleteSpawnEvent(DeleteSpawnEvent&& from) noexcept - : DeleteSpawnEvent() { - *this = ::std::move(from); - } - - inline DeleteSpawnEvent& operator=(DeleteSpawnEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const DeleteSpawnEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const DeleteSpawnEvent* internal_default_instance() { - return reinterpret_cast( - &_DeleteSpawnEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 16; - - void Swap(DeleteSpawnEvent* other); - friend void swap(DeleteSpawnEvent& a, DeleteSpawnEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline DeleteSpawnEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - DeleteSpawnEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const DeleteSpawnEvent& from); - void MergeFrom(const DeleteSpawnEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(DeleteSpawnEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 spawn_id = 1; - void clear_spawn_id(); - static const int kSpawnIdFieldNumber = 1; - ::google::protobuf::uint32 spawn_id() const; - void set_spawn_id(::google::protobuf::uint32 value); - - // uint32 decay = 2; - void clear_decay(); - static const int kDecayFieldNumber = 2; - ::google::protobuf::uint32 decay() const; - void set_decay(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.DeleteSpawnEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 spawn_id_; - ::google::protobuf::uint32 decay_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsDeleteSpawnEventImpl(); -}; -// ------------------------------------------------------------------- - -class HPEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.HPEvent) */ { - public: - HPEvent(); - virtual ~HPEvent(); - - HPEvent(const HPEvent& from); - - inline HPEvent& operator=(const HPEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - HPEvent(HPEvent&& from) noexcept - : HPEvent() { - *this = ::std::move(from); - } - - inline HPEvent& operator=(HPEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const HPEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const HPEvent* internal_default_instance() { - return reinterpret_cast( - &_HPEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 17; - - void Swap(HPEvent* other); - friend void swap(HPEvent& a, HPEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline HPEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - HPEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const HPEvent& from); - void MergeFrom(const HPEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(HPEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 spawn_id = 1; - void clear_spawn_id(); - static const int kSpawnIdFieldNumber = 1; - ::google::protobuf::uint32 spawn_id() const; - void set_spawn_id(::google::protobuf::uint32 value); - - // uint32 cur_hp = 2; - void clear_cur_hp(); - static const int kCurHpFieldNumber = 2; - ::google::protobuf::uint32 cur_hp() const; - void set_cur_hp(::google::protobuf::uint32 value); - - // uint32 max_hp = 3; - void clear_max_hp(); - static const int kMaxHpFieldNumber = 3; - ::google::protobuf::uint32 max_hp() const; - void set_max_hp(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.HPEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 spawn_id_; - ::google::protobuf::uint32 cur_hp_; - ::google::protobuf::uint32 max_hp_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsHPEventImpl(); -}; -// ------------------------------------------------------------------- - -class PlayerPositionUpdateEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.PlayerPositionUpdateEvent) */ { - public: - PlayerPositionUpdateEvent(); - virtual ~PlayerPositionUpdateEvent(); - - PlayerPositionUpdateEvent(const PlayerPositionUpdateEvent& from); - - inline PlayerPositionUpdateEvent& operator=(const PlayerPositionUpdateEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - PlayerPositionUpdateEvent(PlayerPositionUpdateEvent&& from) noexcept - : PlayerPositionUpdateEvent() { - *this = ::std::move(from); - } - - inline PlayerPositionUpdateEvent& operator=(PlayerPositionUpdateEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const PlayerPositionUpdateEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const PlayerPositionUpdateEvent* internal_default_instance() { - return reinterpret_cast( - &_PlayerPositionUpdateEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 18; - - void Swap(PlayerPositionUpdateEvent* other); - friend void swap(PlayerPositionUpdateEvent& a, PlayerPositionUpdateEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline PlayerPositionUpdateEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - PlayerPositionUpdateEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const PlayerPositionUpdateEvent& from); - void MergeFrom(const PlayerPositionUpdateEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(PlayerPositionUpdateEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 spawn_id = 1; - void clear_spawn_id(); - static const int kSpawnIdFieldNumber = 1; - ::google::protobuf::uint32 spawn_id() const; - void set_spawn_id(::google::protobuf::uint32 value); - - // int32 delta_heading = 2; - void clear_delta_heading(); - static const int kDeltaHeadingFieldNumber = 2; - ::google::protobuf::int32 delta_heading() const; - void set_delta_heading(::google::protobuf::int32 value); - - // int32 x_pos = 3; - void clear_x_pos(); - static const int kXPosFieldNumber = 3; - ::google::protobuf::int32 x_pos() const; - void set_x_pos(::google::protobuf::int32 value); - - // int32 padding0002 = 4; - void clear_padding0002(); - static const int kPadding0002FieldNumber = 4; - ::google::protobuf::int32 padding0002() const; - void set_padding0002(::google::protobuf::int32 value); - - // int32 y_pos = 5; - void clear_y_pos(); - static const int kYPosFieldNumber = 5; - ::google::protobuf::int32 y_pos() const; - void set_y_pos(::google::protobuf::int32 value); - - // int32 animation = 6; - void clear_animation(); - static const int kAnimationFieldNumber = 6; - ::google::protobuf::int32 animation() const; - void set_animation(::google::protobuf::int32 value); - - // int32 padding0006 = 7; - void clear_padding0006(); - static const int kPadding0006FieldNumber = 7; - ::google::protobuf::int32 padding0006() const; - void set_padding0006(::google::protobuf::int32 value); - - // int32 z_pos = 8; - void clear_z_pos(); - static const int kZPosFieldNumber = 8; - ::google::protobuf::int32 z_pos() const; - void set_z_pos(::google::protobuf::int32 value); - - // int32 delta_y = 9; - void clear_delta_y(); - static const int kDeltaYFieldNumber = 9; - ::google::protobuf::int32 delta_y() const; - void set_delta_y(::google::protobuf::int32 value); - - // int32 delta_x = 10; - void clear_delta_x(); - static const int kDeltaXFieldNumber = 10; - ::google::protobuf::int32 delta_x() const; - void set_delta_x(::google::protobuf::int32 value); - - // int32 heading = 11; - void clear_heading(); - static const int kHeadingFieldNumber = 11; - ::google::protobuf::int32 heading() const; - void set_heading(::google::protobuf::int32 value); - - // int32 padding0014 = 12; - void clear_padding0014(); - static const int kPadding0014FieldNumber = 12; - ::google::protobuf::int32 padding0014() const; - void set_padding0014(::google::protobuf::int32 value); - - // int32 delta_z = 13; - void clear_delta_z(); - static const int kDeltaZFieldNumber = 13; - ::google::protobuf::int32 delta_z() const; - void set_delta_z(::google::protobuf::int32 value); - - // int32 padding0018 = 14; - void clear_padding0018(); - static const int kPadding0018FieldNumber = 14; - ::google::protobuf::int32 padding0018() const; - void set_padding0018(::google::protobuf::int32 value); - - // @@protoc_insertion_point(class_scope:eqproto.PlayerPositionUpdateEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 spawn_id_; - ::google::protobuf::int32 delta_heading_; - ::google::protobuf::int32 x_pos_; - ::google::protobuf::int32 padding0002_; - ::google::protobuf::int32 y_pos_; - ::google::protobuf::int32 animation_; - ::google::protobuf::int32 padding0006_; - ::google::protobuf::int32 z_pos_; - ::google::protobuf::int32 delta_y_; - ::google::protobuf::int32 delta_x_; - ::google::protobuf::int32 heading_; - ::google::protobuf::int32 padding0014_; - ::google::protobuf::int32 delta_z_; - ::google::protobuf::int32 padding0018_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsPlayerPositionUpdateEventImpl(); -}; -// ------------------------------------------------------------------- - -class AnimationEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.AnimationEvent) */ { - public: - AnimationEvent(); - virtual ~AnimationEvent(); - - AnimationEvent(const AnimationEvent& from); - - inline AnimationEvent& operator=(const AnimationEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - AnimationEvent(AnimationEvent&& from) noexcept - : AnimationEvent() { - *this = ::std::move(from); - } - - inline AnimationEvent& operator=(AnimationEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const AnimationEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const AnimationEvent* internal_default_instance() { - return reinterpret_cast( - &_AnimationEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 19; - - void Swap(AnimationEvent* other); - friend void swap(AnimationEvent& a, AnimationEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline AnimationEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - AnimationEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const AnimationEvent& from); - void MergeFrom(const AnimationEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(AnimationEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // uint32 spawnid = 1; - void clear_spawnid(); - static const int kSpawnidFieldNumber = 1; - ::google::protobuf::uint32 spawnid() const; - void set_spawnid(::google::protobuf::uint32 value); - - // uint32 speed = 2; - void clear_speed(); - static const int kSpeedFieldNumber = 2; - ::google::protobuf::uint32 speed() const; - void set_speed(::google::protobuf::uint32 value); - - // uint32 action = 3; - void clear_action(); - static const int kActionFieldNumber = 3; - ::google::protobuf::uint32 action() const; - void set_action(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.AnimationEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::uint32 spawnid_; - ::google::protobuf::uint32 speed_; - ::google::protobuf::uint32 action_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsAnimationEventImpl(); -}; -// ------------------------------------------------------------------- - -class SpawnEvent : public ::google::protobuf::Message /* @@protoc_insertion_point(class_definition:eqproto.SpawnEvent) */ { - public: - SpawnEvent(); - virtual ~SpawnEvent(); - - SpawnEvent(const SpawnEvent& from); - - inline SpawnEvent& operator=(const SpawnEvent& from) { - CopyFrom(from); - return *this; - } - #if LANG_CXX11 - SpawnEvent(SpawnEvent&& from) noexcept - : SpawnEvent() { - *this = ::std::move(from); - } - - inline SpawnEvent& operator=(SpawnEvent&& from) noexcept { - if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) { - if (this != &from) InternalSwap(&from); - } else { - CopyFrom(from); - } - return *this; - } - #endif - static const ::google::protobuf::Descriptor* descriptor(); - static const SpawnEvent& default_instance(); - - static void InitAsDefaultInstance(); // FOR INTERNAL USE ONLY - static inline const SpawnEvent* internal_default_instance() { - return reinterpret_cast( - &_SpawnEvent_default_instance_); - } - static PROTOBUF_CONSTEXPR int const kIndexInFileMessages = - 20; - - void Swap(SpawnEvent* other); - friend void swap(SpawnEvent& a, SpawnEvent& b) { - a.Swap(&b); - } - - // implements Message ---------------------------------------------- - - inline SpawnEvent* New() const PROTOBUF_FINAL { return New(NULL); } - - SpawnEvent* New(::google::protobuf::Arena* arena) const PROTOBUF_FINAL; - void CopyFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void MergeFrom(const ::google::protobuf::Message& from) PROTOBUF_FINAL; - void CopyFrom(const SpawnEvent& from); - void MergeFrom(const SpawnEvent& from); - void Clear() PROTOBUF_FINAL; - bool IsInitialized() const PROTOBUF_FINAL; - - size_t ByteSizeLong() const PROTOBUF_FINAL; - bool MergePartialFromCodedStream( - ::google::protobuf::io::CodedInputStream* input) PROTOBUF_FINAL; - void SerializeWithCachedSizes( - ::google::protobuf::io::CodedOutputStream* output) const PROTOBUF_FINAL; - ::google::protobuf::uint8* InternalSerializeWithCachedSizesToArray( - bool deterministic, ::google::protobuf::uint8* target) const PROTOBUF_FINAL; - int GetCachedSize() const PROTOBUF_FINAL { return _cached_size_; } - private: - void SharedCtor(); - void SharedDtor(); - void SetCachedSize(int size) const PROTOBUF_FINAL; - void InternalSwap(SpawnEvent* other); - private: - inline ::google::protobuf::Arena* GetArenaNoVirtual() const { - return NULL; - } - inline void* MaybeArenaPtr() const { - return NULL; - } - public: - - ::google::protobuf::Metadata GetMetadata() const PROTOBUF_FINAL; - - // nested types ---------------------------------------------------- - - // accessors ------------------------------------------------------- - - // string name = 8; - void clear_name(); - static const int kNameFieldNumber = 8; - const ::std::string& name() const; - void set_name(const ::std::string& value); - #if LANG_CXX11 - void set_name(::std::string&& value); - #endif - void set_name(const char* value); - void set_name(const char* value, size_t size); - ::std::string* mutable_name(); - ::std::string* release_name(); - void set_allocated_name(::std::string* name); - - // string suffix = 48; - void clear_suffix(); - static const int kSuffixFieldNumber = 48; - const ::std::string& suffix() const; - void set_suffix(const ::std::string& value); - #if LANG_CXX11 - void set_suffix(::std::string&& value); - #endif - void set_suffix(const char* value); - void set_suffix(const char* value, size_t size); - ::std::string* mutable_suffix(); - ::std::string* release_suffix(); - void set_allocated_suffix(::std::string* suffix); - - // string title = 56; - void clear_title(); - static const int kTitleFieldNumber = 56; - const ::std::string& title() const; - void set_title(const ::std::string& value); - #if LANG_CXX11 - void set_title(::std::string&& value); - #endif - void set_title(const char* value); - void set_title(const char* value, size_t size); - ::std::string* mutable_title(); - ::std::string* release_title(); - void set_allocated_title(::std::string* title); - - // string lastName = 62; - void clear_lastname(); - static const int kLastNameFieldNumber = 62; - const ::std::string& lastname() const; - void set_lastname(const ::std::string& value); - #if LANG_CXX11 - void set_lastname(::std::string&& value); - #endif - void set_lastname(const char* value); - void set_lastname(const char* value, size_t size); - ::std::string* mutable_lastname(); - ::std::string* release_lastname(); - void set_allocated_lastname(::std::string* lastname); - - // string DestructibleModel = 82; - void clear_destructiblemodel(); - static const int kDestructibleModelFieldNumber = 82; - const ::std::string& destructiblemodel() const; - void set_destructiblemodel(const ::std::string& value); - #if LANG_CXX11 - void set_destructiblemodel(::std::string&& value); - #endif - void set_destructiblemodel(const char* value); - void set_destructiblemodel(const char* value, size_t size); - ::std::string* mutable_destructiblemodel(); - ::std::string* release_destructiblemodel(); - void set_allocated_destructiblemodel(::std::string* destructiblemodel); - - // string DestructibleName2 = 83; - void clear_destructiblename2(); - static const int kDestructibleName2FieldNumber = 83; - const ::std::string& destructiblename2() const; - void set_destructiblename2(const ::std::string& value); - #if LANG_CXX11 - void set_destructiblename2(::std::string&& value); - #endif - void set_destructiblename2(const char* value); - void set_destructiblename2(const char* value, size_t size); - ::std::string* mutable_destructiblename2(); - ::std::string* release_destructiblename2(); - void set_allocated_destructiblename2(::std::string* destructiblename2); - - // string DestructibleString = 84; - void clear_destructiblestring(); - static const int kDestructibleStringFieldNumber = 84; - const ::std::string& destructiblestring() const; - void set_destructiblestring(const ::std::string& value); - #if LANG_CXX11 - void set_destructiblestring(::std::string&& value); - #endif - void set_destructiblestring(const char* value); - void set_destructiblestring(const char* value, size_t size); - ::std::string* mutable_destructiblestring(); - ::std::string* release_destructiblestring(); - void set_allocated_destructiblestring(::std::string* destructiblestring); - - // .eqproto.TextureProfile equipment = 52; - bool has_equipment() const; - void clear_equipment(); - static const int kEquipmentFieldNumber = 52; - const ::eqproto::TextureProfile& equipment() const; - ::eqproto::TextureProfile* release_equipment(); - ::eqproto::TextureProfile* mutable_equipment(); - void set_allocated_equipment(::eqproto::TextureProfile* equipment); - - // .eqproto.TintProfile equipment_tint = 78; - bool has_equipment_tint() const; - void clear_equipment_tint(); - static const int kEquipmentTintFieldNumber = 78; - const ::eqproto::TintProfile& equipment_tint() const; - ::eqproto::TintProfile* release_equipment_tint(); - ::eqproto::TintProfile* mutable_equipment_tint(); - void set_allocated_equipment_tint(::eqproto::TintProfile* equipment_tint); - - // uint32 unknown0000 = 1; - void clear_unknown0000(); - static const int kUnknown0000FieldNumber = 1; - ::google::protobuf::uint32 unknown0000() const; - void set_unknown0000(::google::protobuf::uint32 value); - - // uint32 gm = 2; - void clear_gm(); - static const int kGmFieldNumber = 2; - ::google::protobuf::uint32 gm() const; - void set_gm(::google::protobuf::uint32 value); - - // uint32 unknown0003 = 3; - void clear_unknown0003(); - static const int kUnknown0003FieldNumber = 3; - ::google::protobuf::uint32 unknown0003() const; - void set_unknown0003(::google::protobuf::uint32 value); - - // uint32 aaitle = 4; - void clear_aaitle(); - static const int kAaitleFieldNumber = 4; - ::google::protobuf::uint32 aaitle() const; - void set_aaitle(::google::protobuf::uint32 value); - - // uint32 unknown0004 = 5; - void clear_unknown0004(); - static const int kUnknown0004FieldNumber = 5; - ::google::protobuf::uint32 unknown0004() const; - void set_unknown0004(::google::protobuf::uint32 value); - - // uint32 anon = 6; - void clear_anon(); - static const int kAnonFieldNumber = 6; - ::google::protobuf::uint32 anon() const; - void set_anon(::google::protobuf::uint32 value); - - // uint32 face = 7; - void clear_face(); - static const int kFaceFieldNumber = 7; - ::google::protobuf::uint32 face() const; - void set_face(::google::protobuf::uint32 value); - - // uint32 deity = 9; - void clear_deity(); - static const int kDeityFieldNumber = 9; - ::google::protobuf::uint32 deity() const; - void set_deity(::google::protobuf::uint32 value); - - // uint32 unknown0073 = 10; - void clear_unknown0073(); - static const int kUnknown0073FieldNumber = 10; - ::google::protobuf::uint32 unknown0073() const; - void set_unknown0073(::google::protobuf::uint32 value); - - // float size = 11; - void clear_size(); - static const int kSizeFieldNumber = 11; - float size() const; - void set_size(float value); - - // uint32 unknown0079 = 12; - void clear_unknown0079(); - static const int kUnknown0079FieldNumber = 12; - ::google::protobuf::uint32 unknown0079() const; - void set_unknown0079(::google::protobuf::uint32 value); - - // uint32 NPC = 13; - void clear_npc(); - static const int kNPCFieldNumber = 13; - ::google::protobuf::uint32 npc() const; - void set_npc(::google::protobuf::uint32 value); - - // uint32 invis = 14; - void clear_invis(); - static const int kInvisFieldNumber = 14; - ::google::protobuf::uint32 invis() const; - void set_invis(::google::protobuf::uint32 value); - - // uint32 haircolor = 15; - void clear_haircolor(); - static const int kHaircolorFieldNumber = 15; - ::google::protobuf::uint32 haircolor() const; - void set_haircolor(::google::protobuf::uint32 value); - - // uint32 curHp = 16; - void clear_curhp(); - static const int kCurHpFieldNumber = 16; - ::google::protobuf::uint32 curhp() const; - void set_curhp(::google::protobuf::uint32 value); - - // uint32 max_hp = 17; - void clear_max_hp(); - static const int kMaxHpFieldNumber = 17; - ::google::protobuf::uint32 max_hp() const; - void set_max_hp(::google::protobuf::uint32 value); - - // uint32 findable = 18; - void clear_findable(); - static const int kFindableFieldNumber = 18; - ::google::protobuf::uint32 findable() const; - void set_findable(::google::protobuf::uint32 value); - - // uint32 unknown0089 = 19; - void clear_unknown0089(); - static const int kUnknown0089FieldNumber = 19; - ::google::protobuf::uint32 unknown0089() const; - void set_unknown0089(::google::protobuf::uint32 value); - - // int32 deltaHeading = 20; - void clear_deltaheading(); - static const int kDeltaHeadingFieldNumber = 20; - ::google::protobuf::int32 deltaheading() const; - void set_deltaheading(::google::protobuf::int32 value); - - // int32 x = 21; - void clear_x(); - static const int kXFieldNumber = 21; - ::google::protobuf::int32 x() const; - void set_x(::google::protobuf::int32 value); - - // int32 padding0054 = 22; - void clear_padding0054(); - static const int kPadding0054FieldNumber = 22; - ::google::protobuf::int32 padding0054() const; - void set_padding0054(::google::protobuf::int32 value); - - // int32 y = 23; - void clear_y(); - static const int kYFieldNumber = 23; - ::google::protobuf::int32 y() const; - void set_y(::google::protobuf::int32 value); - - // int32 animation = 24; - void clear_animation(); - static const int kAnimationFieldNumber = 24; - ::google::protobuf::int32 animation() const; - void set_animation(::google::protobuf::int32 value); - - // int32 padding0058 = 25; - void clear_padding0058(); - static const int kPadding0058FieldNumber = 25; - ::google::protobuf::int32 padding0058() const; - void set_padding0058(::google::protobuf::int32 value); - - // int32 z = 26; - void clear_z(); - static const int kZFieldNumber = 26; - ::google::protobuf::int32 z() const; - void set_z(::google::protobuf::int32 value); - - // int32 deltaY = 27; - void clear_deltay(); - static const int kDeltaYFieldNumber = 27; - ::google::protobuf::int32 deltay() const; - void set_deltay(::google::protobuf::int32 value); - - // int32 deltaX = 28; - void clear_deltax(); - static const int kDeltaXFieldNumber = 28; - ::google::protobuf::int32 deltax() const; - void set_deltax(::google::protobuf::int32 value); - - // uint32 heading = 29; - void clear_heading(); - static const int kHeadingFieldNumber = 29; - ::google::protobuf::uint32 heading() const; - void set_heading(::google::protobuf::uint32 value); - - // int32 padding0066 = 30; - void clear_padding0066(); - static const int kPadding0066FieldNumber = 30; - ::google::protobuf::int32 padding0066() const; - void set_padding0066(::google::protobuf::int32 value); - - // int32 deltaZ = 31; - void clear_deltaz(); - static const int kDeltaZFieldNumber = 31; - ::google::protobuf::int32 deltaz() const; - void set_deltaz(::google::protobuf::int32 value); - - // int32 padding0070 = 32; - void clear_padding0070(); - static const int kPadding0070FieldNumber = 32; - ::google::protobuf::int32 padding0070() const; - void set_padding0070(::google::protobuf::int32 value); - - // uint32 eyecolor1 = 33; - void clear_eyecolor1(); - static const int kEyecolor1FieldNumber = 33; - ::google::protobuf::uint32 eyecolor1() const; - void set_eyecolor1(::google::protobuf::uint32 value); - - // uint32 unknown0115 = 34; - void clear_unknown0115(); - static const int kUnknown0115FieldNumber = 34; - ::google::protobuf::uint32 unknown0115() const; - void set_unknown0115(::google::protobuf::uint32 value); - - // uint32 StandState = 35; - void clear_standstate(); - static const int kStandStateFieldNumber = 35; - ::google::protobuf::uint32 standstate() const; - void set_standstate(::google::protobuf::uint32 value); - - // uint32 drakkin_heritage = 36; - void clear_drakkin_heritage(); - static const int kDrakkinHeritageFieldNumber = 36; - ::google::protobuf::uint32 drakkin_heritage() const; - void set_drakkin_heritage(::google::protobuf::uint32 value); - - // uint32 drakkin_tattoo = 37; - void clear_drakkin_tattoo(); - static const int kDrakkinTattooFieldNumber = 37; - ::google::protobuf::uint32 drakkin_tattoo() const; - void set_drakkin_tattoo(::google::protobuf::uint32 value); - - // uint32 drakkin_details = 38; - void clear_drakkin_details(); - static const int kDrakkinDetailsFieldNumber = 38; - ::google::protobuf::uint32 drakkin_details() const; - void set_drakkin_details(::google::protobuf::uint32 value); - - // uint32 showhelm = 39; - void clear_showhelm(); - static const int kShowhelmFieldNumber = 39; - ::google::protobuf::uint32 showhelm() const; - void set_showhelm(::google::protobuf::uint32 value); - - // uint32 unknown0140 = 40; - void clear_unknown0140(); - static const int kUnknown0140FieldNumber = 40; - ::google::protobuf::uint32 unknown0140() const; - void set_unknown0140(::google::protobuf::uint32 value); - - // uint32 is_npc = 41; - void clear_is_npc(); - static const int kIsNpcFieldNumber = 41; - ::google::protobuf::uint32 is_npc() const; - void set_is_npc(::google::protobuf::uint32 value); - - // uint32 hairstyle = 42; - void clear_hairstyle(); - static const int kHairstyleFieldNumber = 42; - ::google::protobuf::uint32 hairstyle() const; - void set_hairstyle(::google::protobuf::uint32 value); - - // uint32 beard = 43; - void clear_beard(); - static const int kBeardFieldNumber = 43; - ::google::protobuf::uint32 beard() const; - void set_beard(::google::protobuf::uint32 value); - - // uint32 unknown0147 = 44; - void clear_unknown0147(); - static const int kUnknown0147FieldNumber = 44; - ::google::protobuf::uint32 unknown0147() const; - void set_unknown0147(::google::protobuf::uint32 value); - - // uint32 level = 45; - void clear_level(); - static const int kLevelFieldNumber = 45; - ::google::protobuf::uint32 level() const; - void set_level(::google::protobuf::uint32 value); - - // uint32 PlayerState = 46; - void clear_playerstate(); - static const int kPlayerStateFieldNumber = 46; - ::google::protobuf::uint32 playerstate() const; - void set_playerstate(::google::protobuf::uint32 value); - - // uint32 beardcolor = 47; - void clear_beardcolor(); - static const int kBeardcolorFieldNumber = 47; - ::google::protobuf::uint32 beardcolor() const; - void set_beardcolor(::google::protobuf::uint32 value); - - // uint32 petOwnerId = 49; - void clear_petownerid(); - static const int kPetOwnerIdFieldNumber = 49; - ::google::protobuf::uint32 petownerid() const; - void set_petownerid(::google::protobuf::uint32 value); - - // uint32 guildrank = 50; - void clear_guildrank(); - static const int kGuildrankFieldNumber = 50; - ::google::protobuf::uint32 guildrank() const; - void set_guildrank(::google::protobuf::uint32 value); - - // uint32 unknown0194 = 51; - void clear_unknown0194(); - static const int kUnknown0194FieldNumber = 51; - ::google::protobuf::uint32 unknown0194() const; - void set_unknown0194(::google::protobuf::uint32 value); - - // float runspeed = 53; - void clear_runspeed(); - static const int kRunspeedFieldNumber = 53; - float runspeed() const; - void set_runspeed(float value); - - // uint32 afk = 54; - void clear_afk(); - static const int kAfkFieldNumber = 54; - ::google::protobuf::uint32 afk() const; - void set_afk(::google::protobuf::uint32 value); - - // uint32 guildID = 55; - void clear_guildid(); - static const int kGuildIDFieldNumber = 55; - ::google::protobuf::uint32 guildid() const; - void set_guildid(::google::protobuf::uint32 value); - - // uint32 unknown0274 = 57; - void clear_unknown0274(); - static const int kUnknown0274FieldNumber = 57; - ::google::protobuf::uint32 unknown0274() const; - void set_unknown0274(::google::protobuf::uint32 value); - - // uint32 set_to_0xFF = 58; - void clear_set_to_0xff(); - static const int kSetTo0XFFFieldNumber = 58; - ::google::protobuf::uint32 set_to_0xff() const; - void set_set_to_0xff(::google::protobuf::uint32 value); - - // uint32 helm = 59; - void clear_helm(); - static const int kHelmFieldNumber = 59; - ::google::protobuf::uint32 helm() const; - void set_helm(::google::protobuf::uint32 value); - - // uint32 race = 60; - void clear_race(); - static const int kRaceFieldNumber = 60; - ::google::protobuf::uint32 race() const; - void set_race(::google::protobuf::uint32 value); - - // uint32 unknown0288 = 61; - void clear_unknown0288(); - static const int kUnknown0288FieldNumber = 61; - ::google::protobuf::uint32 unknown0288() const; - void set_unknown0288(::google::protobuf::uint32 value); - - // float walkspeed = 63; - void clear_walkspeed(); - static const int kWalkspeedFieldNumber = 63; - float walkspeed() const; - void set_walkspeed(float value); - - // uint32 unknown0328 = 64; - void clear_unknown0328(); - static const int kUnknown0328FieldNumber = 64; - ::google::protobuf::uint32 unknown0328() const; - void set_unknown0328(::google::protobuf::uint32 value); - - // uint32 is_pet = 65; - void clear_is_pet(); - static const int kIsPetFieldNumber = 65; - ::google::protobuf::uint32 is_pet() const; - void set_is_pet(::google::protobuf::uint32 value); - - // uint32 light = 66; - void clear_light(); - static const int kLightFieldNumber = 66; - ::google::protobuf::uint32 light() const; - void set_light(::google::protobuf::uint32 value); - - // uint32 class_ = 67; - void clear_class_(); - static const int kClassFieldNumber = 67; - ::google::protobuf::uint32 class_() const; - void set_class_(::google::protobuf::uint32 value); - - // uint32 eyecolor2 = 68; - void clear_eyecolor2(); - static const int kEyecolor2FieldNumber = 68; - ::google::protobuf::uint32 eyecolor2() const; - void set_eyecolor2(::google::protobuf::uint32 value); - - // uint32 flymode = 69; - void clear_flymode(); - static const int kFlymodeFieldNumber = 69; - ::google::protobuf::uint32 flymode() const; - void set_flymode(::google::protobuf::uint32 value); - - // uint32 gender = 70; - void clear_gender(); - static const int kGenderFieldNumber = 70; - ::google::protobuf::uint32 gender() const; - void set_gender(::google::protobuf::uint32 value); - - // uint32 bodytype = 71; - void clear_bodytype(); - static const int kBodytypeFieldNumber = 71; - ::google::protobuf::uint32 bodytype() const; - void set_bodytype(::google::protobuf::uint32 value); - - // uint32 unknown0336 = 72; - void clear_unknown0336(); - static const int kUnknown0336FieldNumber = 72; - ::google::protobuf::uint32 unknown0336() const; - void set_unknown0336(::google::protobuf::uint32 value); - - // uint32 equip_chest2 = 73; - void clear_equip_chest2(); - static const int kEquipChest2FieldNumber = 73; - ::google::protobuf::uint32 equip_chest2() const; - void set_equip_chest2(::google::protobuf::uint32 value); - - // uint32 mount_color = 74; - void clear_mount_color(); - static const int kMountColorFieldNumber = 74; - ::google::protobuf::uint32 mount_color() const; - void set_mount_color(::google::protobuf::uint32 value); - - // uint32 spawnId = 75; - void clear_spawnid(); - static const int kSpawnIdFieldNumber = 75; - ::google::protobuf::uint32 spawnid() const; - void set_spawnid(::google::protobuf::uint32 value); - - // uint32 unknown0344 = 76; - void clear_unknown0344(); - static const int kUnknown0344FieldNumber = 76; - ::google::protobuf::uint32 unknown0344() const; - void set_unknown0344(::google::protobuf::uint32 value); - - // uint32 IsMercenary = 77; - void clear_ismercenary(); - static const int kIsMercenaryFieldNumber = 77; - ::google::protobuf::uint32 ismercenary() const; - void set_ismercenary(::google::protobuf::uint32 value); - - // uint32 lfg = 79; - void clear_lfg(); - static const int kLfgFieldNumber = 79; - ::google::protobuf::uint32 lfg() const; - void set_lfg(::google::protobuf::uint32 value); - - // uint32 DestructibleAppearance = 85; - void clear_destructibleappearance(); - static const int kDestructibleAppearanceFieldNumber = 85; - ::google::protobuf::uint32 destructibleappearance() const; - void set_destructibleappearance(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk1 = 86; - void clear_destructibleunk1(); - static const int kDestructibleUnk1FieldNumber = 86; - ::google::protobuf::uint32 destructibleunk1() const; - void set_destructibleunk1(::google::protobuf::uint32 value); - - // uint32 DestructibleID1 = 87; - void clear_destructibleid1(); - static const int kDestructibleID1FieldNumber = 87; - ::google::protobuf::uint32 destructibleid1() const; - void set_destructibleid1(::google::protobuf::uint32 value); - - // uint32 DestructibleID2 = 88; - void clear_destructibleid2(); - static const int kDestructibleID2FieldNumber = 88; - ::google::protobuf::uint32 destructibleid2() const; - void set_destructibleid2(::google::protobuf::uint32 value); - - // uint32 DestructibleID3 = 89; - void clear_destructibleid3(); - static const int kDestructibleID3FieldNumber = 89; - ::google::protobuf::uint32 destructibleid3() const; - void set_destructibleid3(::google::protobuf::uint32 value); - - // uint32 DestructibleID4 = 90; - void clear_destructibleid4(); - static const int kDestructibleID4FieldNumber = 90; - ::google::protobuf::uint32 destructibleid4() const; - void set_destructibleid4(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk2 = 91; - void clear_destructibleunk2(); - static const int kDestructibleUnk2FieldNumber = 91; - ::google::protobuf::uint32 destructibleunk2() const; - void set_destructibleunk2(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk3 = 92; - void clear_destructibleunk3(); - static const int kDestructibleUnk3FieldNumber = 92; - ::google::protobuf::uint32 destructibleunk3() const; - void set_destructibleunk3(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk4 = 93; - void clear_destructibleunk4(); - static const int kDestructibleUnk4FieldNumber = 93; - ::google::protobuf::uint32 destructibleunk4() const; - void set_destructibleunk4(::google::protobuf::uint32 value); - - // bool DestructibleObject = 80; - void clear_destructibleobject(); - static const int kDestructibleObjectFieldNumber = 80; - bool destructibleobject() const; - void set_destructibleobject(bool value); - - // bool targetable_with_hotkey = 99; - void clear_targetable_with_hotkey(); - static const int kTargetableWithHotkeyFieldNumber = 99; - bool targetable_with_hotkey() const; - void set_targetable_with_hotkey(bool value); - - // bool show_name = 100; - void clear_show_name(); - static const int kShowNameFieldNumber = 100; - bool show_name() const; - void set_show_name(bool value); - - // uint32 DestructibleUnk5 = 94; - void clear_destructibleunk5(); - static const int kDestructibleUnk5FieldNumber = 94; - ::google::protobuf::uint32 destructibleunk5() const; - void set_destructibleunk5(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk6 = 95; - void clear_destructibleunk6(); - static const int kDestructibleUnk6FieldNumber = 95; - ::google::protobuf::uint32 destructibleunk6() const; - void set_destructibleunk6(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk7 = 96; - void clear_destructibleunk7(); - static const int kDestructibleUnk7FieldNumber = 96; - ::google::protobuf::uint32 destructibleunk7() const; - void set_destructibleunk7(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk8 = 97; - void clear_destructibleunk8(); - static const int kDestructibleUnk8FieldNumber = 97; - ::google::protobuf::uint32 destructibleunk8() const; - void set_destructibleunk8(::google::protobuf::uint32 value); - - // uint32 DestructibleUnk9 = 98; - void clear_destructibleunk9(); - static const int kDestructibleUnk9FieldNumber = 98; - ::google::protobuf::uint32 destructibleunk9() const; - void set_destructibleunk9(::google::protobuf::uint32 value); - - // @@protoc_insertion_point(class_scope:eqproto.SpawnEvent) - private: - - ::google::protobuf::internal::InternalMetadataWithArena _internal_metadata_; - ::google::protobuf::internal::ArenaStringPtr name_; - ::google::protobuf::internal::ArenaStringPtr suffix_; - ::google::protobuf::internal::ArenaStringPtr title_; - ::google::protobuf::internal::ArenaStringPtr lastname_; - ::google::protobuf::internal::ArenaStringPtr destructiblemodel_; - ::google::protobuf::internal::ArenaStringPtr destructiblename2_; - ::google::protobuf::internal::ArenaStringPtr destructiblestring_; - ::eqproto::TextureProfile* equipment_; - ::eqproto::TintProfile* equipment_tint_; - ::google::protobuf::uint32 unknown0000_; - ::google::protobuf::uint32 gm_; - ::google::protobuf::uint32 unknown0003_; - ::google::protobuf::uint32 aaitle_; - ::google::protobuf::uint32 unknown0004_; - ::google::protobuf::uint32 anon_; - ::google::protobuf::uint32 face_; - ::google::protobuf::uint32 deity_; - ::google::protobuf::uint32 unknown0073_; - float size_; - ::google::protobuf::uint32 unknown0079_; - ::google::protobuf::uint32 npc_; - ::google::protobuf::uint32 invis_; - ::google::protobuf::uint32 haircolor_; - ::google::protobuf::uint32 curhp_; - ::google::protobuf::uint32 max_hp_; - ::google::protobuf::uint32 findable_; - ::google::protobuf::uint32 unknown0089_; - ::google::protobuf::int32 deltaheading_; - ::google::protobuf::int32 x_; - ::google::protobuf::int32 padding0054_; - ::google::protobuf::int32 y_; - ::google::protobuf::int32 animation_; - ::google::protobuf::int32 padding0058_; - ::google::protobuf::int32 z_; - ::google::protobuf::int32 deltay_; - ::google::protobuf::int32 deltax_; - ::google::protobuf::uint32 heading_; - ::google::protobuf::int32 padding0066_; - ::google::protobuf::int32 deltaz_; - ::google::protobuf::int32 padding0070_; - ::google::protobuf::uint32 eyecolor1_; - ::google::protobuf::uint32 unknown0115_; - ::google::protobuf::uint32 standstate_; - ::google::protobuf::uint32 drakkin_heritage_; - ::google::protobuf::uint32 drakkin_tattoo_; - ::google::protobuf::uint32 drakkin_details_; - ::google::protobuf::uint32 showhelm_; - ::google::protobuf::uint32 unknown0140_; - ::google::protobuf::uint32 is_npc_; - ::google::protobuf::uint32 hairstyle_; - ::google::protobuf::uint32 beard_; - ::google::protobuf::uint32 unknown0147_; - ::google::protobuf::uint32 level_; - ::google::protobuf::uint32 playerstate_; - ::google::protobuf::uint32 beardcolor_; - ::google::protobuf::uint32 petownerid_; - ::google::protobuf::uint32 guildrank_; - ::google::protobuf::uint32 unknown0194_; - float runspeed_; - ::google::protobuf::uint32 afk_; - ::google::protobuf::uint32 guildid_; - ::google::protobuf::uint32 unknown0274_; - ::google::protobuf::uint32 set_to_0xff_; - ::google::protobuf::uint32 helm_; - ::google::protobuf::uint32 race_; - ::google::protobuf::uint32 unknown0288_; - float walkspeed_; - ::google::protobuf::uint32 unknown0328_; - ::google::protobuf::uint32 is_pet_; - ::google::protobuf::uint32 light_; - ::google::protobuf::uint32 class__; - ::google::protobuf::uint32 eyecolor2_; - ::google::protobuf::uint32 flymode_; - ::google::protobuf::uint32 gender_; - ::google::protobuf::uint32 bodytype_; - ::google::protobuf::uint32 unknown0336_; - ::google::protobuf::uint32 equip_chest2_; - ::google::protobuf::uint32 mount_color_; - ::google::protobuf::uint32 spawnid_; - ::google::protobuf::uint32 unknown0344_; - ::google::protobuf::uint32 ismercenary_; - ::google::protobuf::uint32 lfg_; - ::google::protobuf::uint32 destructibleappearance_; - ::google::protobuf::uint32 destructibleunk1_; - ::google::protobuf::uint32 destructibleid1_; - ::google::protobuf::uint32 destructibleid2_; - ::google::protobuf::uint32 destructibleid3_; - ::google::protobuf::uint32 destructibleid4_; - ::google::protobuf::uint32 destructibleunk2_; - ::google::protobuf::uint32 destructibleunk3_; - ::google::protobuf::uint32 destructibleunk4_; - bool destructibleobject_; - bool targetable_with_hotkey_; - bool show_name_; - ::google::protobuf::uint32 destructibleunk5_; - ::google::protobuf::uint32 destructibleunk6_; - ::google::protobuf::uint32 destructibleunk7_; - ::google::protobuf::uint32 destructibleunk8_; - ::google::protobuf::uint32 destructibleunk9_; - mutable int _cached_size_; - friend struct ::protobuf_message_2eproto::TableStruct; - friend void ::protobuf_message_2eproto::InitDefaultsSpawnEventImpl(); -}; -// =================================================================== - - -// =================================================================== - -#ifdef __GNUC__ - #pragma GCC diagnostic push - #pragma GCC diagnostic ignored "-Wstrict-aliasing" -#endif // __GNUC__ -// ChannelMessage - -// int32 chan_num = 1; -inline void ChannelMessage::clear_chan_num() { - chan_num_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::chan_num() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.chan_num) - return chan_num_; -} -inline void ChannelMessage::set_chan_num(::google::protobuf::int32 value) { - - chan_num_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.chan_num) -} - -// int32 language = 2; -inline void ChannelMessage::clear_language() { - language_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::language() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.language) - return language_; -} -inline void ChannelMessage::set_language(::google::protobuf::int32 value) { - - language_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.language) -} - -// string from = 3; -inline void ChannelMessage::clear_from() { - from_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessage::from() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.from) - return from_.GetNoArena(); -} -inline void ChannelMessage::set_from(const ::std::string& value) { - - from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.from) -} -#if LANG_CXX11 -inline void ChannelMessage::set_from(::std::string&& value) { - - from_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessage.from) -} -#endif -inline void ChannelMessage::set_from(const char* value) { - GOOGLE_DCHECK(value != NULL); - - from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessage.from) -} -inline void ChannelMessage::set_from(const char* value, size_t size) { - - from_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessage.from) -} -inline ::std::string* ChannelMessage::mutable_from() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessage.from) - return from_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessage::release_from() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessage.from) - - return from_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessage::set_allocated_from(::std::string* from) { - if (from != NULL) { - - } else { - - } - from_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), from); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessage.from) -} - -// string to = 4; -inline void ChannelMessage::clear_to() { - to_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessage::to() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.to) - return to_.GetNoArena(); -} -inline void ChannelMessage::set_to(const ::std::string& value) { - - to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.to) -} -#if LANG_CXX11 -inline void ChannelMessage::set_to(::std::string&& value) { - - to_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessage.to) -} -#endif -inline void ChannelMessage::set_to(const char* value) { - GOOGLE_DCHECK(value != NULL); - - to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessage.to) -} -inline void ChannelMessage::set_to(const char* value, size_t size) { - - to_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessage.to) -} -inline ::std::string* ChannelMessage::mutable_to() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessage.to) - return to_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessage::release_to() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessage.to) - - return to_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessage::set_allocated_to(::std::string* to) { - if (to != NULL) { - - } else { - - } - to_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), to); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessage.to) -} - -// string message = 5; -inline void ChannelMessage::clear_message() { - message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessage::message() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.message) - return message_.GetNoArena(); -} -inline void ChannelMessage::set_message(const ::std::string& value) { - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.message) -} -#if LANG_CXX11 -inline void ChannelMessage::set_message(::std::string&& value) { - - message_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessage.message) -} -#endif -inline void ChannelMessage::set_message(const char* value) { - GOOGLE_DCHECK(value != NULL); - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessage.message) -} -inline void ChannelMessage::set_message(const char* value, size_t size) { - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessage.message) -} -inline ::std::string* ChannelMessage::mutable_message() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessage.message) - return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessage::release_message() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessage.message) - - return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessage::set_allocated_message(::std::string* message) { - if (message != NULL) { - - } else { - - } - message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessage.message) -} - -// int32 guilddbid = 6; -inline void ChannelMessage::clear_guilddbid() { - guilddbid_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::guilddbid() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.guilddbid) - return guilddbid_; -} -inline void ChannelMessage::set_guilddbid(::google::protobuf::int32 value) { - - guilddbid_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.guilddbid) -} - -// string deliverto = 7; -inline void ChannelMessage::clear_deliverto() { - deliverto_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessage::deliverto() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.deliverto) - return deliverto_.GetNoArena(); -} -inline void ChannelMessage::set_deliverto(const ::std::string& value) { - - deliverto_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.deliverto) -} -#if LANG_CXX11 -inline void ChannelMessage::set_deliverto(::std::string&& value) { - - deliverto_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessage.deliverto) -} -#endif -inline void ChannelMessage::set_deliverto(const char* value) { - GOOGLE_DCHECK(value != NULL); - - deliverto_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessage.deliverto) -} -inline void ChannelMessage::set_deliverto(const char* value, size_t size) { - - deliverto_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessage.deliverto) -} -inline ::std::string* ChannelMessage::mutable_deliverto() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessage.deliverto) - return deliverto_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessage::release_deliverto() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessage.deliverto) - - return deliverto_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessage::set_allocated_deliverto(::std::string* deliverto) { - if (deliverto != NULL) { - - } else { - - } - deliverto_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), deliverto); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessage.deliverto) -} - -// int32 type = 8; -inline void ChannelMessage::clear_type() { - type_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::type() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.type) - return type_; -} -inline void ChannelMessage::set_type(::google::protobuf::int32 value) { - - type_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.type) -} - -// int32 minstatus = 9; -inline void ChannelMessage::clear_minstatus() { - minstatus_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::minstatus() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.minstatus) - return minstatus_; -} -inline void ChannelMessage::set_minstatus(::google::protobuf::int32 value) { - - minstatus_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.minstatus) -} - -// int32 fromadmin = 10; -inline void ChannelMessage::clear_fromadmin() { - fromadmin_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::fromadmin() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.fromadmin) - return fromadmin_; -} -inline void ChannelMessage::set_fromadmin(::google::protobuf::int32 value) { - - fromadmin_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.fromadmin) -} - -// bool noreply = 11; -inline void ChannelMessage::clear_noreply() { - noreply_ = false; -} -inline bool ChannelMessage::noreply() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.noreply) - return noreply_; -} -inline void ChannelMessage::set_noreply(bool value) { - - noreply_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.noreply) -} - -// bool is_emote = 12; -inline void ChannelMessage::clear_is_emote() { - is_emote_ = false; -} -inline bool ChannelMessage::is_emote() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.is_emote) - return is_emote_; -} -inline void ChannelMessage::set_is_emote(bool value) { - - is_emote_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.is_emote) -} - -// int32 queued = 13; -inline void ChannelMessage::clear_queued() { - queued_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::queued() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.queued) - return queued_; -} -inline void ChannelMessage::set_queued(::google::protobuf::int32 value) { - - queued_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.queued) -} - -// int32 zone_id = 14; -inline void ChannelMessage::clear_zone_id() { - zone_id_ = 0; -} -inline ::google::protobuf::int32 ChannelMessage::zone_id() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessage.zone_id) - return zone_id_; -} -inline void ChannelMessage::set_zone_id(::google::protobuf::int32 value) { - - zone_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessage.zone_id) -} - -// ------------------------------------------------------------------- - -// CommandMessage - -// string author = 1; -inline void CommandMessage::clear_author() { - author_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& CommandMessage::author() const { - // @@protoc_insertion_point(field_get:eqproto.CommandMessage.author) - return author_.GetNoArena(); -} -inline void CommandMessage::set_author(const ::std::string& value) { - - author_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.author) -} -#if LANG_CXX11 -inline void CommandMessage::set_author(::std::string&& value) { - - author_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.CommandMessage.author) -} -#endif -inline void CommandMessage::set_author(const char* value) { - GOOGLE_DCHECK(value != NULL); - - author_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.CommandMessage.author) -} -inline void CommandMessage::set_author(const char* value, size_t size) { - - author_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.CommandMessage.author) -} -inline ::std::string* CommandMessage::mutable_author() { - - // @@protoc_insertion_point(field_mutable:eqproto.CommandMessage.author) - return author_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* CommandMessage::release_author() { - // @@protoc_insertion_point(field_release:eqproto.CommandMessage.author) - - return author_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void CommandMessage::set_allocated_author(::std::string* author) { - if (author != NULL) { - - } else { - - } - author_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), author); - // @@protoc_insertion_point(field_set_allocated:eqproto.CommandMessage.author) -} - -// string command = 2; -inline void CommandMessage::clear_command() { - command_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& CommandMessage::command() const { - // @@protoc_insertion_point(field_get:eqproto.CommandMessage.command) - return command_.GetNoArena(); -} -inline void CommandMessage::set_command(const ::std::string& value) { - - command_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.command) -} -#if LANG_CXX11 -inline void CommandMessage::set_command(::std::string&& value) { - - command_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.CommandMessage.command) -} -#endif -inline void CommandMessage::set_command(const char* value) { - GOOGLE_DCHECK(value != NULL); - - command_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.CommandMessage.command) -} -inline void CommandMessage::set_command(const char* value, size_t size) { - - command_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.CommandMessage.command) -} -inline ::std::string* CommandMessage::mutable_command() { - - // @@protoc_insertion_point(field_mutable:eqproto.CommandMessage.command) - return command_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* CommandMessage::release_command() { - // @@protoc_insertion_point(field_release:eqproto.CommandMessage.command) - - return command_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void CommandMessage::set_allocated_command(::std::string* command) { - if (command != NULL) { - - } else { - - } - command_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), command); - // @@protoc_insertion_point(field_set_allocated:eqproto.CommandMessage.command) -} - -// repeated string params = 3; -inline int CommandMessage::params_size() const { - return params_.size(); -} -inline void CommandMessage::clear_params() { - params_.Clear(); -} -inline const ::std::string& CommandMessage::params(int index) const { - // @@protoc_insertion_point(field_get:eqproto.CommandMessage.params) - return params_.Get(index); -} -inline ::std::string* CommandMessage::mutable_params(int index) { - // @@protoc_insertion_point(field_mutable:eqproto.CommandMessage.params) - return params_.Mutable(index); -} -inline void CommandMessage::set_params(int index, const ::std::string& value) { - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.params) - params_.Mutable(index)->assign(value); -} -#if LANG_CXX11 -inline void CommandMessage::set_params(int index, ::std::string&& value) { - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.params) - params_.Mutable(index)->assign(std::move(value)); -} -#endif -inline void CommandMessage::set_params(int index, const char* value) { - GOOGLE_DCHECK(value != NULL); - params_.Mutable(index)->assign(value); - // @@protoc_insertion_point(field_set_char:eqproto.CommandMessage.params) -} -inline void CommandMessage::set_params(int index, const char* value, size_t size) { - params_.Mutable(index)->assign( - reinterpret_cast(value), size); - // @@protoc_insertion_point(field_set_pointer:eqproto.CommandMessage.params) -} -inline ::std::string* CommandMessage::add_params() { - // @@protoc_insertion_point(field_add_mutable:eqproto.CommandMessage.params) - return params_.Add(); -} -inline void CommandMessage::add_params(const ::std::string& value) { - params_.Add()->assign(value); - // @@protoc_insertion_point(field_add:eqproto.CommandMessage.params) -} -#if LANG_CXX11 -inline void CommandMessage::add_params(::std::string&& value) { - params_.Add(std::move(value)); - // @@protoc_insertion_point(field_add:eqproto.CommandMessage.params) -} -#endif -inline void CommandMessage::add_params(const char* value) { - GOOGLE_DCHECK(value != NULL); - params_.Add()->assign(value); - // @@protoc_insertion_point(field_add_char:eqproto.CommandMessage.params) -} -inline void CommandMessage::add_params(const char* value, size_t size) { - params_.Add()->assign(reinterpret_cast(value), size); - // @@protoc_insertion_point(field_add_pointer:eqproto.CommandMessage.params) -} -inline const ::google::protobuf::RepeatedPtrField< ::std::string>& -CommandMessage::params() const { - // @@protoc_insertion_point(field_list:eqproto.CommandMessage.params) - return params_; -} -inline ::google::protobuf::RepeatedPtrField< ::std::string>* -CommandMessage::mutable_params() { - // @@protoc_insertion_point(field_mutable_list:eqproto.CommandMessage.params) - return ¶ms_; -} - -// string result = 4; -inline void CommandMessage::clear_result() { - result_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& CommandMessage::result() const { - // @@protoc_insertion_point(field_get:eqproto.CommandMessage.result) - return result_.GetNoArena(); -} -inline void CommandMessage::set_result(const ::std::string& value) { - - result_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.result) -} -#if LANG_CXX11 -inline void CommandMessage::set_result(::std::string&& value) { - - result_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.CommandMessage.result) -} -#endif -inline void CommandMessage::set_result(const char* value) { - GOOGLE_DCHECK(value != NULL); - - result_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.CommandMessage.result) -} -inline void CommandMessage::set_result(const char* value, size_t size) { - - result_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.CommandMessage.result) -} -inline ::std::string* CommandMessage::mutable_result() { - - // @@protoc_insertion_point(field_mutable:eqproto.CommandMessage.result) - return result_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* CommandMessage::release_result() { - // @@protoc_insertion_point(field_release:eqproto.CommandMessage.result) - - return result_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void CommandMessage::set_allocated_result(::std::string* result) { - if (result != NULL) { - - } else { - - } - result_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), result); - // @@protoc_insertion_point(field_set_allocated:eqproto.CommandMessage.result) -} - -// bytes payload = 5; -inline void CommandMessage::clear_payload() { - payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& CommandMessage::payload() const { - // @@protoc_insertion_point(field_get:eqproto.CommandMessage.payload) - return payload_.GetNoArena(); -} -inline void CommandMessage::set_payload(const ::std::string& value) { - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.CommandMessage.payload) -} -#if LANG_CXX11 -inline void CommandMessage::set_payload(::std::string&& value) { - - payload_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.CommandMessage.payload) -} -#endif -inline void CommandMessage::set_payload(const char* value) { - GOOGLE_DCHECK(value != NULL); - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.CommandMessage.payload) -} -inline void CommandMessage::set_payload(const void* value, size_t size) { - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.CommandMessage.payload) -} -inline ::std::string* CommandMessage::mutable_payload() { - - // @@protoc_insertion_point(field_mutable:eqproto.CommandMessage.payload) - return payload_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* CommandMessage::release_payload() { - // @@protoc_insertion_point(field_release:eqproto.CommandMessage.payload) - - return payload_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void CommandMessage::set_allocated_payload(::std::string* payload) { - if (payload != NULL) { - - } else { - - } - payload_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), payload); - // @@protoc_insertion_point(field_set_allocated:eqproto.CommandMessage.payload) -} - -// ------------------------------------------------------------------- - -// DailyGain - -// int32 account_id = 1; -inline void DailyGain::clear_account_id() { - account_id_ = 0; -} -inline ::google::protobuf::int32 DailyGain::account_id() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.account_id) - return account_id_; -} -inline void DailyGain::set_account_id(::google::protobuf::int32 value) { - - account_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DailyGain.account_id) -} - -// int32 character_id = 2; -inline void DailyGain::clear_character_id() { - character_id_ = 0; -} -inline ::google::protobuf::int32 DailyGain::character_id() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.character_id) - return character_id_; -} -inline void DailyGain::set_character_id(::google::protobuf::int32 value) { - - character_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DailyGain.character_id) -} - -// int32 levels_gained = 3; -inline void DailyGain::clear_levels_gained() { - levels_gained_ = 0; -} -inline ::google::protobuf::int32 DailyGain::levels_gained() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.levels_gained) - return levels_gained_; -} -inline void DailyGain::set_levels_gained(::google::protobuf::int32 value) { - - levels_gained_ = value; - // @@protoc_insertion_point(field_set:eqproto.DailyGain.levels_gained) -} - -// int32 experience_gained = 4; -inline void DailyGain::clear_experience_gained() { - experience_gained_ = 0; -} -inline ::google::protobuf::int32 DailyGain::experience_gained() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.experience_gained) - return experience_gained_; -} -inline void DailyGain::set_experience_gained(::google::protobuf::int32 value) { - - experience_gained_ = value; - // @@protoc_insertion_point(field_set:eqproto.DailyGain.experience_gained) -} - -// int32 money_earned = 5; -inline void DailyGain::clear_money_earned() { - money_earned_ = 0; -} -inline ::google::protobuf::int32 DailyGain::money_earned() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.money_earned) - return money_earned_; -} -inline void DailyGain::set_money_earned(::google::protobuf::int32 value) { - - money_earned_ = value; - // @@protoc_insertion_point(field_set:eqproto.DailyGain.money_earned) -} - -// string identity = 6; -inline void DailyGain::clear_identity() { - identity_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& DailyGain::identity() const { - // @@protoc_insertion_point(field_get:eqproto.DailyGain.identity) - return identity_.GetNoArena(); -} -inline void DailyGain::set_identity(const ::std::string& value) { - - identity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.DailyGain.identity) -} -#if LANG_CXX11 -inline void DailyGain::set_identity(::std::string&& value) { - - identity_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.DailyGain.identity) -} -#endif -inline void DailyGain::set_identity(const char* value) { - GOOGLE_DCHECK(value != NULL); - - identity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.DailyGain.identity) -} -inline void DailyGain::set_identity(const char* value, size_t size) { - - identity_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.DailyGain.identity) -} -inline ::std::string* DailyGain::mutable_identity() { - - // @@protoc_insertion_point(field_mutable:eqproto.DailyGain.identity) - return identity_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* DailyGain::release_identity() { - // @@protoc_insertion_point(field_release:eqproto.DailyGain.identity) - - return identity_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void DailyGain::set_allocated_identity(::std::string* identity) { - if (identity != NULL) { - - } else { - - } - identity_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), identity); - // @@protoc_insertion_point(field_set_allocated:eqproto.DailyGain.identity) -} - -// ------------------------------------------------------------------- - -// Entity - -// int32 id = 1; -inline void Entity::clear_id() { - id_ = 0; -} -inline ::google::protobuf::int32 Entity::id() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.id) - return id_; -} -inline void Entity::set_id(::google::protobuf::int32 value) { - - id_ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.id) -} - -// string name = 2; -inline void Entity::clear_name() { - name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& Entity::name() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.name) - return name_.GetNoArena(); -} -inline void Entity::set_name(const ::std::string& value) { - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.Entity.name) -} -#if LANG_CXX11 -inline void Entity::set_name(::std::string&& value) { - - name_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.Entity.name) -} -#endif -inline void Entity::set_name(const char* value) { - GOOGLE_DCHECK(value != NULL); - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.Entity.name) -} -inline void Entity::set_name(const char* value, size_t size) { - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.Entity.name) -} -inline ::std::string* Entity::mutable_name() { - - // @@protoc_insertion_point(field_mutable:eqproto.Entity.name) - return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* Entity::release_name() { - // @@protoc_insertion_point(field_release:eqproto.Entity.name) - - return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void Entity::set_allocated_name(::std::string* name) { - if (name != NULL) { - - } else { - - } - name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); - // @@protoc_insertion_point(field_set_allocated:eqproto.Entity.name) -} - -// int32 type = 3; -inline void Entity::clear_type() { - type_ = 0; -} -inline ::google::protobuf::int32 Entity::type() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.type) - return type_; -} -inline void Entity::set_type(::google::protobuf::int32 value) { - - type_ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.type) -} - -// int32 hp = 4; -inline void Entity::clear_hp() { - hp_ = 0; -} -inline ::google::protobuf::int32 Entity::hp() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.hp) - return hp_; -} -inline void Entity::set_hp(::google::protobuf::int32 value) { - - hp_ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.hp) -} - -// int32 level = 5; -inline void Entity::clear_level() { - level_ = 0; -} -inline ::google::protobuf::int32 Entity::level() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.level) - return level_; -} -inline void Entity::set_level(::google::protobuf::int32 value) { - - level_ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.level) -} - -// .eqproto.Position position = 6; -inline bool Entity::has_position() const { - return this != internal_default_instance() && position_ != NULL; -} -inline void Entity::clear_position() { - if (GetArenaNoVirtual() == NULL && position_ != NULL) { - delete position_; - } - position_ = NULL; -} -inline const ::eqproto::Position& Entity::position() const { - const ::eqproto::Position* p = position_; - // @@protoc_insertion_point(field_get:eqproto.Entity.position) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Position_default_instance_); -} -inline ::eqproto::Position* Entity::release_position() { - // @@protoc_insertion_point(field_release:eqproto.Entity.position) - - ::eqproto::Position* temp = position_; - position_ = NULL; - return temp; -} -inline ::eqproto::Position* Entity::mutable_position() { - - if (position_ == NULL) { - position_ = new ::eqproto::Position; - } - // @@protoc_insertion_point(field_mutable:eqproto.Entity.position) - return position_; -} -inline void Entity::set_allocated_position(::eqproto::Position* position) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete position_; - } - if (position) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - position = ::google::protobuf::internal::GetOwnedMessage( - message_arena, position, submessage_arena); - } - - } else { - - } - position_ = position; - // @@protoc_insertion_point(field_set_allocated:eqproto.Entity.position) -} - -// int32 race = 7; -inline void Entity::clear_race() { - race_ = 0; -} -inline ::google::protobuf::int32 Entity::race() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.race) - return race_; -} -inline void Entity::set_race(::google::protobuf::int32 value) { - - race_ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.race) -} - -// int32 class = 8; -inline void Entity::clear_class_() { - class__ = 0; -} -inline ::google::protobuf::int32 Entity::class_() const { - // @@protoc_insertion_point(field_get:eqproto.Entity.class) - return class__; -} -inline void Entity::set_class_(::google::protobuf::int32 value) { - - class__ = value; - // @@protoc_insertion_point(field_set:eqproto.Entity.class) -} - -// ------------------------------------------------------------------- - -// Entities - -// repeated .eqproto.Entity entities = 1; -inline int Entities::entities_size() const { - return entities_.size(); -} -inline void Entities::clear_entities() { - entities_.Clear(); -} -inline const ::eqproto::Entity& Entities::entities(int index) const { - // @@protoc_insertion_point(field_get:eqproto.Entities.entities) - return entities_.Get(index); -} -inline ::eqproto::Entity* Entities::mutable_entities(int index) { - // @@protoc_insertion_point(field_mutable:eqproto.Entities.entities) - return entities_.Mutable(index); -} -inline ::eqproto::Entity* Entities::add_entities() { - // @@protoc_insertion_point(field_add:eqproto.Entities.entities) - return entities_.Add(); -} -inline ::google::protobuf::RepeatedPtrField< ::eqproto::Entity >* -Entities::mutable_entities() { - // @@protoc_insertion_point(field_mutable_list:eqproto.Entities.entities) - return &entities_; -} -inline const ::google::protobuf::RepeatedPtrField< ::eqproto::Entity >& -Entities::entities() const { - // @@protoc_insertion_point(field_list:eqproto.Entities.entities) - return entities_; -} - -// ------------------------------------------------------------------- - -// Position - -// float x = 1; -inline void Position::clear_x() { - x_ = 0; -} -inline float Position::x() const { - // @@protoc_insertion_point(field_get:eqproto.Position.x) - return x_; -} -inline void Position::set_x(float value) { - - x_ = value; - // @@protoc_insertion_point(field_set:eqproto.Position.x) -} - -// float y = 2; -inline void Position::clear_y() { - y_ = 0; -} -inline float Position::y() const { - // @@protoc_insertion_point(field_get:eqproto.Position.y) - return y_; -} -inline void Position::set_y(float value) { - - y_ = value; - // @@protoc_insertion_point(field_set:eqproto.Position.y) -} - -// float z = 3; -inline void Position::clear_z() { - z_ = 0; -} -inline float Position::z() const { - // @@protoc_insertion_point(field_get:eqproto.Position.z) - return z_; -} -inline void Position::set_z(float value) { - - z_ = value; - // @@protoc_insertion_point(field_set:eqproto.Position.z) -} - -// float h = 4; -inline void Position::clear_h() { - h_ = 0; -} -inline float Position::h() const { - // @@protoc_insertion_point(field_get:eqproto.Position.h) - return h_; -} -inline void Position::set_h(float value) { - - h_ = value; - // @@protoc_insertion_point(field_set:eqproto.Position.h) -} - -// ------------------------------------------------------------------- - -// TextureProfile - -// .eqproto.Texture Head = 1; -inline bool TextureProfile::has_head() const { - return this != internal_default_instance() && head_ != NULL; -} -inline void TextureProfile::clear_head() { - if (GetArenaNoVirtual() == NULL && head_ != NULL) { - delete head_; - } - head_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::head() const { - const ::eqproto::Texture* p = head_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Head) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_head() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Head) - - ::eqproto::Texture* temp = head_; - head_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_head() { - - if (head_ == NULL) { - head_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Head) - return head_; -} -inline void TextureProfile::set_allocated_head(::eqproto::Texture* head) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete head_; - } - if (head) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - head = ::google::protobuf::internal::GetOwnedMessage( - message_arena, head, submessage_arena); - } - - } else { - - } - head_ = head; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Head) -} - -// .eqproto.Texture Chest = 2; -inline bool TextureProfile::has_chest() const { - return this != internal_default_instance() && chest_ != NULL; -} -inline void TextureProfile::clear_chest() { - if (GetArenaNoVirtual() == NULL && chest_ != NULL) { - delete chest_; - } - chest_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::chest() const { - const ::eqproto::Texture* p = chest_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Chest) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_chest() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Chest) - - ::eqproto::Texture* temp = chest_; - chest_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_chest() { - - if (chest_ == NULL) { - chest_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Chest) - return chest_; -} -inline void TextureProfile::set_allocated_chest(::eqproto::Texture* chest) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete chest_; - } - if (chest) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - chest = ::google::protobuf::internal::GetOwnedMessage( - message_arena, chest, submessage_arena); - } - - } else { - - } - chest_ = chest; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Chest) -} - -// .eqproto.Texture Arms = 3; -inline bool TextureProfile::has_arms() const { - return this != internal_default_instance() && arms_ != NULL; -} -inline void TextureProfile::clear_arms() { - if (GetArenaNoVirtual() == NULL && arms_ != NULL) { - delete arms_; - } - arms_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::arms() const { - const ::eqproto::Texture* p = arms_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Arms) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_arms() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Arms) - - ::eqproto::Texture* temp = arms_; - arms_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_arms() { - - if (arms_ == NULL) { - arms_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Arms) - return arms_; -} -inline void TextureProfile::set_allocated_arms(::eqproto::Texture* arms) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete arms_; - } - if (arms) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - arms = ::google::protobuf::internal::GetOwnedMessage( - message_arena, arms, submessage_arena); - } - - } else { - - } - arms_ = arms; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Arms) -} - -// .eqproto.Texture Wrist = 4; -inline bool TextureProfile::has_wrist() const { - return this != internal_default_instance() && wrist_ != NULL; -} -inline void TextureProfile::clear_wrist() { - if (GetArenaNoVirtual() == NULL && wrist_ != NULL) { - delete wrist_; - } - wrist_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::wrist() const { - const ::eqproto::Texture* p = wrist_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Wrist) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_wrist() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Wrist) - - ::eqproto::Texture* temp = wrist_; - wrist_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_wrist() { - - if (wrist_ == NULL) { - wrist_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Wrist) - return wrist_; -} -inline void TextureProfile::set_allocated_wrist(::eqproto::Texture* wrist) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete wrist_; - } - if (wrist) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - wrist = ::google::protobuf::internal::GetOwnedMessage( - message_arena, wrist, submessage_arena); - } - - } else { - - } - wrist_ = wrist; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Wrist) -} - -// .eqproto.Texture Hands = 5; -inline bool TextureProfile::has_hands() const { - return this != internal_default_instance() && hands_ != NULL; -} -inline void TextureProfile::clear_hands() { - if (GetArenaNoVirtual() == NULL && hands_ != NULL) { - delete hands_; - } - hands_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::hands() const { - const ::eqproto::Texture* p = hands_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Hands) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_hands() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Hands) - - ::eqproto::Texture* temp = hands_; - hands_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_hands() { - - if (hands_ == NULL) { - hands_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Hands) - return hands_; -} -inline void TextureProfile::set_allocated_hands(::eqproto::Texture* hands) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete hands_; - } - if (hands) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - hands = ::google::protobuf::internal::GetOwnedMessage( - message_arena, hands, submessage_arena); - } - - } else { - - } - hands_ = hands; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Hands) -} - -// .eqproto.Texture Legs = 6; -inline bool TextureProfile::has_legs() const { - return this != internal_default_instance() && legs_ != NULL; -} -inline void TextureProfile::clear_legs() { - if (GetArenaNoVirtual() == NULL && legs_ != NULL) { - delete legs_; - } - legs_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::legs() const { - const ::eqproto::Texture* p = legs_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Legs) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_legs() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Legs) - - ::eqproto::Texture* temp = legs_; - legs_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_legs() { - - if (legs_ == NULL) { - legs_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Legs) - return legs_; -} -inline void TextureProfile::set_allocated_legs(::eqproto::Texture* legs) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete legs_; - } - if (legs) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - legs = ::google::protobuf::internal::GetOwnedMessage( - message_arena, legs, submessage_arena); - } - - } else { - - } - legs_ = legs; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Legs) -} - -// .eqproto.Texture Feet = 7; -inline bool TextureProfile::has_feet() const { - return this != internal_default_instance() && feet_ != NULL; -} -inline void TextureProfile::clear_feet() { - if (GetArenaNoVirtual() == NULL && feet_ != NULL) { - delete feet_; - } - feet_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::feet() const { - const ::eqproto::Texture* p = feet_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Feet) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_feet() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Feet) - - ::eqproto::Texture* temp = feet_; - feet_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_feet() { - - if (feet_ == NULL) { - feet_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Feet) - return feet_; -} -inline void TextureProfile::set_allocated_feet(::eqproto::Texture* feet) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete feet_; - } - if (feet) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - feet = ::google::protobuf::internal::GetOwnedMessage( - message_arena, feet, submessage_arena); - } - - } else { - - } - feet_ = feet; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Feet) -} - -// .eqproto.Texture Primary = 8; -inline bool TextureProfile::has_primary() const { - return this != internal_default_instance() && primary_ != NULL; -} -inline void TextureProfile::clear_primary() { - if (GetArenaNoVirtual() == NULL && primary_ != NULL) { - delete primary_; - } - primary_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::primary() const { - const ::eqproto::Texture* p = primary_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Primary) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_primary() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Primary) - - ::eqproto::Texture* temp = primary_; - primary_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_primary() { - - if (primary_ == NULL) { - primary_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Primary) - return primary_; -} -inline void TextureProfile::set_allocated_primary(::eqproto::Texture* primary) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete primary_; - } - if (primary) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - primary = ::google::protobuf::internal::GetOwnedMessage( - message_arena, primary, submessage_arena); - } - - } else { - - } - primary_ = primary; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Primary) -} - -// .eqproto.Texture Secondary = 9; -inline bool TextureProfile::has_secondary() const { - return this != internal_default_instance() && secondary_ != NULL; -} -inline void TextureProfile::clear_secondary() { - if (GetArenaNoVirtual() == NULL && secondary_ != NULL) { - delete secondary_; - } - secondary_ = NULL; -} -inline const ::eqproto::Texture& TextureProfile::secondary() const { - const ::eqproto::Texture* p = secondary_; - // @@protoc_insertion_point(field_get:eqproto.TextureProfile.Secondary) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Texture_default_instance_); -} -inline ::eqproto::Texture* TextureProfile::release_secondary() { - // @@protoc_insertion_point(field_release:eqproto.TextureProfile.Secondary) - - ::eqproto::Texture* temp = secondary_; - secondary_ = NULL; - return temp; -} -inline ::eqproto::Texture* TextureProfile::mutable_secondary() { - - if (secondary_ == NULL) { - secondary_ = new ::eqproto::Texture; - } - // @@protoc_insertion_point(field_mutable:eqproto.TextureProfile.Secondary) - return secondary_; -} -inline void TextureProfile::set_allocated_secondary(::eqproto::Texture* secondary) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete secondary_; - } - if (secondary) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - secondary = ::google::protobuf::internal::GetOwnedMessage( - message_arena, secondary, submessage_arena); - } - - } else { - - } - secondary_ = secondary; - // @@protoc_insertion_point(field_set_allocated:eqproto.TextureProfile.Secondary) -} - -// ------------------------------------------------------------------- - -// Texture - -// uint32 material = 1; -inline void Texture::clear_material() { - material_ = 0u; -} -inline ::google::protobuf::uint32 Texture::material() const { - // @@protoc_insertion_point(field_get:eqproto.Texture.material) - return material_; -} -inline void Texture::set_material(::google::protobuf::uint32 value) { - - material_ = value; - // @@protoc_insertion_point(field_set:eqproto.Texture.material) -} - -// uint32 unknown1 = 2; -inline void Texture::clear_unknown1() { - unknown1_ = 0u; -} -inline ::google::protobuf::uint32 Texture::unknown1() const { - // @@protoc_insertion_point(field_get:eqproto.Texture.unknown1) - return unknown1_; -} -inline void Texture::set_unknown1(::google::protobuf::uint32 value) { - - unknown1_ = value; - // @@protoc_insertion_point(field_set:eqproto.Texture.unknown1) -} - -// uint32 EliteModel = 3; -inline void Texture::clear_elitemodel() { - elitemodel_ = 0u; -} -inline ::google::protobuf::uint32 Texture::elitemodel() const { - // @@protoc_insertion_point(field_get:eqproto.Texture.EliteModel) - return elitemodel_; -} -inline void Texture::set_elitemodel(::google::protobuf::uint32 value) { - - elitemodel_ = value; - // @@protoc_insertion_point(field_set:eqproto.Texture.EliteModel) -} - -// uint32 HerosForgeModel = 4; -inline void Texture::clear_herosforgemodel() { - herosforgemodel_ = 0u; -} -inline ::google::protobuf::uint32 Texture::herosforgemodel() const { - // @@protoc_insertion_point(field_get:eqproto.Texture.HerosForgeModel) - return herosforgemodel_; -} -inline void Texture::set_herosforgemodel(::google::protobuf::uint32 value) { - - herosforgemodel_ = value; - // @@protoc_insertion_point(field_set:eqproto.Texture.HerosForgeModel) -} - -// uint32 Unknown2 = 5; -inline void Texture::clear_unknown2() { - unknown2_ = 0u; -} -inline ::google::protobuf::uint32 Texture::unknown2() const { - // @@protoc_insertion_point(field_get:eqproto.Texture.Unknown2) - return unknown2_; -} -inline void Texture::set_unknown2(::google::protobuf::uint32 value) { - - unknown2_ = value; - // @@protoc_insertion_point(field_set:eqproto.Texture.Unknown2) -} - -// ------------------------------------------------------------------- - -// TintProfile - -// .eqproto.Tint Head = 1; -inline bool TintProfile::has_head() const { - return this != internal_default_instance() && head_ != NULL; -} -inline void TintProfile::clear_head() { - if (GetArenaNoVirtual() == NULL && head_ != NULL) { - delete head_; - } - head_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::head() const { - const ::eqproto::Tint* p = head_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Head) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_head() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Head) - - ::eqproto::Tint* temp = head_; - head_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_head() { - - if (head_ == NULL) { - head_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Head) - return head_; -} -inline void TintProfile::set_allocated_head(::eqproto::Tint* head) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete head_; - } - if (head) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - head = ::google::protobuf::internal::GetOwnedMessage( - message_arena, head, submessage_arena); - } - - } else { - - } - head_ = head; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Head) -} - -// .eqproto.Tint Chest = 2; -inline bool TintProfile::has_chest() const { - return this != internal_default_instance() && chest_ != NULL; -} -inline void TintProfile::clear_chest() { - if (GetArenaNoVirtual() == NULL && chest_ != NULL) { - delete chest_; - } - chest_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::chest() const { - const ::eqproto::Tint* p = chest_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Chest) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_chest() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Chest) - - ::eqproto::Tint* temp = chest_; - chest_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_chest() { - - if (chest_ == NULL) { - chest_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Chest) - return chest_; -} -inline void TintProfile::set_allocated_chest(::eqproto::Tint* chest) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete chest_; - } - if (chest) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - chest = ::google::protobuf::internal::GetOwnedMessage( - message_arena, chest, submessage_arena); - } - - } else { - - } - chest_ = chest; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Chest) -} - -// .eqproto.Tint Arms = 3; -inline bool TintProfile::has_arms() const { - return this != internal_default_instance() && arms_ != NULL; -} -inline void TintProfile::clear_arms() { - if (GetArenaNoVirtual() == NULL && arms_ != NULL) { - delete arms_; - } - arms_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::arms() const { - const ::eqproto::Tint* p = arms_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Arms) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_arms() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Arms) - - ::eqproto::Tint* temp = arms_; - arms_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_arms() { - - if (arms_ == NULL) { - arms_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Arms) - return arms_; -} -inline void TintProfile::set_allocated_arms(::eqproto::Tint* arms) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete arms_; - } - if (arms) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - arms = ::google::protobuf::internal::GetOwnedMessage( - message_arena, arms, submessage_arena); - } - - } else { - - } - arms_ = arms; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Arms) -} - -// .eqproto.Tint Wrist = 4; -inline bool TintProfile::has_wrist() const { - return this != internal_default_instance() && wrist_ != NULL; -} -inline void TintProfile::clear_wrist() { - if (GetArenaNoVirtual() == NULL && wrist_ != NULL) { - delete wrist_; - } - wrist_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::wrist() const { - const ::eqproto::Tint* p = wrist_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Wrist) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_wrist() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Wrist) - - ::eqproto::Tint* temp = wrist_; - wrist_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_wrist() { - - if (wrist_ == NULL) { - wrist_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Wrist) - return wrist_; -} -inline void TintProfile::set_allocated_wrist(::eqproto::Tint* wrist) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete wrist_; - } - if (wrist) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - wrist = ::google::protobuf::internal::GetOwnedMessage( - message_arena, wrist, submessage_arena); - } - - } else { - - } - wrist_ = wrist; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Wrist) -} - -// .eqproto.Tint Hands = 5; -inline bool TintProfile::has_hands() const { - return this != internal_default_instance() && hands_ != NULL; -} -inline void TintProfile::clear_hands() { - if (GetArenaNoVirtual() == NULL && hands_ != NULL) { - delete hands_; - } - hands_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::hands() const { - const ::eqproto::Tint* p = hands_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Hands) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_hands() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Hands) - - ::eqproto::Tint* temp = hands_; - hands_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_hands() { - - if (hands_ == NULL) { - hands_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Hands) - return hands_; -} -inline void TintProfile::set_allocated_hands(::eqproto::Tint* hands) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete hands_; - } - if (hands) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - hands = ::google::protobuf::internal::GetOwnedMessage( - message_arena, hands, submessage_arena); - } - - } else { - - } - hands_ = hands; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Hands) -} - -// .eqproto.Tint Legs = 6; -inline bool TintProfile::has_legs() const { - return this != internal_default_instance() && legs_ != NULL; -} -inline void TintProfile::clear_legs() { - if (GetArenaNoVirtual() == NULL && legs_ != NULL) { - delete legs_; - } - legs_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::legs() const { - const ::eqproto::Tint* p = legs_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Legs) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_legs() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Legs) - - ::eqproto::Tint* temp = legs_; - legs_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_legs() { - - if (legs_ == NULL) { - legs_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Legs) - return legs_; -} -inline void TintProfile::set_allocated_legs(::eqproto::Tint* legs) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete legs_; - } - if (legs) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - legs = ::google::protobuf::internal::GetOwnedMessage( - message_arena, legs, submessage_arena); - } - - } else { - - } - legs_ = legs; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Legs) -} - -// .eqproto.Tint Feet = 7; -inline bool TintProfile::has_feet() const { - return this != internal_default_instance() && feet_ != NULL; -} -inline void TintProfile::clear_feet() { - if (GetArenaNoVirtual() == NULL && feet_ != NULL) { - delete feet_; - } - feet_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::feet() const { - const ::eqproto::Tint* p = feet_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Feet) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_feet() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Feet) - - ::eqproto::Tint* temp = feet_; - feet_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_feet() { - - if (feet_ == NULL) { - feet_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Feet) - return feet_; -} -inline void TintProfile::set_allocated_feet(::eqproto::Tint* feet) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete feet_; - } - if (feet) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - feet = ::google::protobuf::internal::GetOwnedMessage( - message_arena, feet, submessage_arena); - } - - } else { - - } - feet_ = feet; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Feet) -} - -// .eqproto.Tint Primary = 8; -inline bool TintProfile::has_primary() const { - return this != internal_default_instance() && primary_ != NULL; -} -inline void TintProfile::clear_primary() { - if (GetArenaNoVirtual() == NULL && primary_ != NULL) { - delete primary_; - } - primary_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::primary() const { - const ::eqproto::Tint* p = primary_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Primary) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_primary() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Primary) - - ::eqproto::Tint* temp = primary_; - primary_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_primary() { - - if (primary_ == NULL) { - primary_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Primary) - return primary_; -} -inline void TintProfile::set_allocated_primary(::eqproto::Tint* primary) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete primary_; - } - if (primary) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - primary = ::google::protobuf::internal::GetOwnedMessage( - message_arena, primary, submessage_arena); - } - - } else { - - } - primary_ = primary; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Primary) -} - -// .eqproto.Tint Secondary = 9; -inline bool TintProfile::has_secondary() const { - return this != internal_default_instance() && secondary_ != NULL; -} -inline void TintProfile::clear_secondary() { - if (GetArenaNoVirtual() == NULL && secondary_ != NULL) { - delete secondary_; - } - secondary_ = NULL; -} -inline const ::eqproto::Tint& TintProfile::secondary() const { - const ::eqproto::Tint* p = secondary_; - // @@protoc_insertion_point(field_get:eqproto.TintProfile.Secondary) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* TintProfile::release_secondary() { - // @@protoc_insertion_point(field_release:eqproto.TintProfile.Secondary) - - ::eqproto::Tint* temp = secondary_; - secondary_ = NULL; - return temp; -} -inline ::eqproto::Tint* TintProfile::mutable_secondary() { - - if (secondary_ == NULL) { - secondary_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.TintProfile.Secondary) - return secondary_; -} -inline void TintProfile::set_allocated_secondary(::eqproto::Tint* secondary) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete secondary_; - } - if (secondary) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - secondary = ::google::protobuf::internal::GetOwnedMessage( - message_arena, secondary, submessage_arena); - } - - } else { - - } - secondary_ = secondary; - // @@protoc_insertion_point(field_set_allocated:eqproto.TintProfile.Secondary) -} - -// ------------------------------------------------------------------- - -// Tint - -// uint32 Blue = 1; -inline void Tint::clear_blue() { - blue_ = 0u; -} -inline ::google::protobuf::uint32 Tint::blue() const { - // @@protoc_insertion_point(field_get:eqproto.Tint.Blue) - return blue_; -} -inline void Tint::set_blue(::google::protobuf::uint32 value) { - - blue_ = value; - // @@protoc_insertion_point(field_set:eqproto.Tint.Blue) -} - -// uint32 Green = 2; -inline void Tint::clear_green() { - green_ = 0u; -} -inline ::google::protobuf::uint32 Tint::green() const { - // @@protoc_insertion_point(field_get:eqproto.Tint.Green) - return green_; -} -inline void Tint::set_green(::google::protobuf::uint32 value) { - - green_ = value; - // @@protoc_insertion_point(field_set:eqproto.Tint.Green) -} - -// uint32 Red = 3; -inline void Tint::clear_red() { - red_ = 0u; -} -inline ::google::protobuf::uint32 Tint::red() const { - // @@protoc_insertion_point(field_get:eqproto.Tint.Red) - return red_; -} -inline void Tint::set_red(::google::protobuf::uint32 value) { - - red_ = value; - // @@protoc_insertion_point(field_set:eqproto.Tint.Red) -} - -// uint32 UseTint = 4; -inline void Tint::clear_usetint() { - usetint_ = 0u; -} -inline ::google::protobuf::uint32 Tint::usetint() const { - // @@protoc_insertion_point(field_get:eqproto.Tint.UseTint) - return usetint_; -} -inline void Tint::set_usetint(::google::protobuf::uint32 value) { - - usetint_ = value; - // @@protoc_insertion_point(field_set:eqproto.Tint.UseTint) -} - -// uint32 Color = 5; -inline void Tint::clear_color() { - color_ = 0u; -} -inline ::google::protobuf::uint32 Tint::color() const { - // @@protoc_insertion_point(field_get:eqproto.Tint.Color) - return color_; -} -inline void Tint::set_color(::google::protobuf::uint32 value) { - - color_ = value; - // @@protoc_insertion_point(field_set:eqproto.Tint.Color) -} - -// ------------------------------------------------------------------- - -// Event - -// .eqproto.OpCode op = 1; -inline void Event::clear_op() { - op_ = 0; -} -inline ::eqproto::OpCode Event::op() const { - // @@protoc_insertion_point(field_get:eqproto.Event.op) - return static_cast< ::eqproto::OpCode >(op_); -} -inline void Event::set_op(::eqproto::OpCode value) { - - op_ = value; - // @@protoc_insertion_point(field_set:eqproto.Event.op) -} - -// bytes payload = 2; -inline void Event::clear_payload() { - payload_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& Event::payload() const { - // @@protoc_insertion_point(field_get:eqproto.Event.payload) - return payload_.GetNoArena(); -} -inline void Event::set_payload(const ::std::string& value) { - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.Event.payload) -} -#if LANG_CXX11 -inline void Event::set_payload(::std::string&& value) { - - payload_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.Event.payload) -} -#endif -inline void Event::set_payload(const char* value) { - GOOGLE_DCHECK(value != NULL); - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.Event.payload) -} -inline void Event::set_payload(const void* value, size_t size) { - - payload_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.Event.payload) -} -inline ::std::string* Event::mutable_payload() { - - // @@protoc_insertion_point(field_mutable:eqproto.Event.payload) - return payload_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* Event::release_payload() { - // @@protoc_insertion_point(field_release:eqproto.Event.payload) - - return payload_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void Event::set_allocated_payload(::std::string* payload) { - if (payload != NULL) { - - } else { - - } - payload_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), payload); - // @@protoc_insertion_point(field_set_allocated:eqproto.Event.payload) -} - -// ------------------------------------------------------------------- - -// DeathEvent - -// uint32 spawn_id = 1; -inline void DeathEvent::clear_spawn_id() { - spawn_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::spawn_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.spawn_id) - return spawn_id_; -} -inline void DeathEvent::set_spawn_id(::google::protobuf::uint32 value) { - - spawn_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.spawn_id) -} - -// uint32 killer_id = 2; -inline void DeathEvent::clear_killer_id() { - killer_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::killer_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.killer_id) - return killer_id_; -} -inline void DeathEvent::set_killer_id(::google::protobuf::uint32 value) { - - killer_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.killer_id) -} - -// uint32 corpse_id = 3; -inline void DeathEvent::clear_corpse_id() { - corpse_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::corpse_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.corpse_id) - return corpse_id_; -} -inline void DeathEvent::set_corpse_id(::google::protobuf::uint32 value) { - - corpse_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.corpse_id) -} - -// uint32 bind_zone_id = 4; -inline void DeathEvent::clear_bind_zone_id() { - bind_zone_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::bind_zone_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.bind_zone_id) - return bind_zone_id_; -} -inline void DeathEvent::set_bind_zone_id(::google::protobuf::uint32 value) { - - bind_zone_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.bind_zone_id) -} - -// uint32 spell_id = 5; -inline void DeathEvent::clear_spell_id() { - spell_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::spell_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.spell_id) - return spell_id_; -} -inline void DeathEvent::set_spell_id(::google::protobuf::uint32 value) { - - spell_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.spell_id) -} - -// uint32 attack_skill_id = 6; -inline void DeathEvent::clear_attack_skill_id() { - attack_skill_id_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::attack_skill_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.attack_skill_id) - return attack_skill_id_; -} -inline void DeathEvent::set_attack_skill_id(::google::protobuf::uint32 value) { - - attack_skill_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.attack_skill_id) -} - -// uint32 damage = 7; -inline void DeathEvent::clear_damage() { - damage_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::damage() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.damage) - return damage_; -} -inline void DeathEvent::set_damage(::google::protobuf::uint32 value) { - - damage_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.damage) -} - -// uint32 unknown028 = 8; -inline void DeathEvent::clear_unknown028() { - unknown028_ = 0u; -} -inline ::google::protobuf::uint32 DeathEvent::unknown028() const { - // @@protoc_insertion_point(field_get:eqproto.DeathEvent.unknown028) - return unknown028_; -} -inline void DeathEvent::set_unknown028(::google::protobuf::uint32 value) { - - unknown028_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeathEvent.unknown028) -} - -// ------------------------------------------------------------------- - -// DamageEvent - -// uint32 target = 1; -inline void DamageEvent::clear_target() { - target_ = 0u; -} -inline ::google::protobuf::uint32 DamageEvent::target() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.target) - return target_; -} -inline void DamageEvent::set_target(::google::protobuf::uint32 value) { - - target_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.target) -} - -// uint32 source = 2; -inline void DamageEvent::clear_source() { - source_ = 0u; -} -inline ::google::protobuf::uint32 DamageEvent::source() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.source) - return source_; -} -inline void DamageEvent::set_source(::google::protobuf::uint32 value) { - - source_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.source) -} - -// uint32 type = 3; -inline void DamageEvent::clear_type() { - type_ = 0u; -} -inline ::google::protobuf::uint32 DamageEvent::type() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.type) - return type_; -} -inline void DamageEvent::set_type(::google::protobuf::uint32 value) { - - type_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.type) -} - -// uint32 spellid = 4; -inline void DamageEvent::clear_spellid() { - spellid_ = 0u; -} -inline ::google::protobuf::uint32 DamageEvent::spellid() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.spellid) - return spellid_; -} -inline void DamageEvent::set_spellid(::google::protobuf::uint32 value) { - - spellid_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.spellid) -} - -// uint32 damage = 5; -inline void DamageEvent::clear_damage() { - damage_ = 0u; -} -inline ::google::protobuf::uint32 DamageEvent::damage() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.damage) - return damage_; -} -inline void DamageEvent::set_damage(::google::protobuf::uint32 value) { - - damage_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.damage) -} - -// float force = 6; -inline void DamageEvent::clear_force() { - force_ = 0; -} -inline float DamageEvent::force() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.force) - return force_; -} -inline void DamageEvent::set_force(float value) { - - force_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.force) -} - -// float meleepush_xy = 7; -inline void DamageEvent::clear_meleepush_xy() { - meleepush_xy_ = 0; -} -inline float DamageEvent::meleepush_xy() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.meleepush_xy) - return meleepush_xy_; -} -inline void DamageEvent::set_meleepush_xy(float value) { - - meleepush_xy_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.meleepush_xy) -} - -// float meleepush_z = 8; -inline void DamageEvent::clear_meleepush_z() { - meleepush_z_ = 0; -} -inline float DamageEvent::meleepush_z() const { - // @@protoc_insertion_point(field_get:eqproto.DamageEvent.meleepush_z) - return meleepush_z_; -} -inline void DamageEvent::set_meleepush_z(float value) { - - meleepush_z_ = value; - // @@protoc_insertion_point(field_set:eqproto.DamageEvent.meleepush_z) -} - -// ------------------------------------------------------------------- - -// EntityEvent - -// uint32 entity_id = 1; -inline void EntityEvent::clear_entity_id() { - entity_id_ = 0u; -} -inline ::google::protobuf::uint32 EntityEvent::entity_id() const { - // @@protoc_insertion_point(field_get:eqproto.EntityEvent.entity_id) - return entity_id_; -} -inline void EntityEvent::set_entity_id(::google::protobuf::uint32 value) { - - entity_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.EntityEvent.entity_id) -} - -// uint32 target_id = 2; -inline void EntityEvent::clear_target_id() { - target_id_ = 0u; -} -inline ::google::protobuf::uint32 EntityEvent::target_id() const { - // @@protoc_insertion_point(field_get:eqproto.EntityEvent.target_id) - return target_id_; -} -inline void EntityEvent::set_target_id(::google::protobuf::uint32 value) { - - target_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.EntityEvent.target_id) -} - -// ------------------------------------------------------------------- - -// ChannelMessageEvent - -// string target_name = 1; -inline void ChannelMessageEvent::clear_target_name() { - target_name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessageEvent::target_name() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.target_name) - return target_name_.GetNoArena(); -} -inline void ChannelMessageEvent::set_target_name(const ::std::string& value) { - - target_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.target_name) -} -#if LANG_CXX11 -inline void ChannelMessageEvent::set_target_name(::std::string&& value) { - - target_name_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessageEvent.target_name) -} -#endif -inline void ChannelMessageEvent::set_target_name(const char* value) { - GOOGLE_DCHECK(value != NULL); - - target_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessageEvent.target_name) -} -inline void ChannelMessageEvent::set_target_name(const char* value, size_t size) { - - target_name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessageEvent.target_name) -} -inline ::std::string* ChannelMessageEvent::mutable_target_name() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessageEvent.target_name) - return target_name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessageEvent::release_target_name() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessageEvent.target_name) - - return target_name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessageEvent::set_allocated_target_name(::std::string* target_name) { - if (target_name != NULL) { - - } else { - - } - target_name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), target_name); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessageEvent.target_name) -} - -// string sender = 2; -inline void ChannelMessageEvent::clear_sender() { - sender_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessageEvent::sender() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.sender) - return sender_.GetNoArena(); -} -inline void ChannelMessageEvent::set_sender(const ::std::string& value) { - - sender_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.sender) -} -#if LANG_CXX11 -inline void ChannelMessageEvent::set_sender(::std::string&& value) { - - sender_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessageEvent.sender) -} -#endif -inline void ChannelMessageEvent::set_sender(const char* value) { - GOOGLE_DCHECK(value != NULL); - - sender_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessageEvent.sender) -} -inline void ChannelMessageEvent::set_sender(const char* value, size_t size) { - - sender_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessageEvent.sender) -} -inline ::std::string* ChannelMessageEvent::mutable_sender() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessageEvent.sender) - return sender_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessageEvent::release_sender() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessageEvent.sender) - - return sender_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessageEvent::set_allocated_sender(::std::string* sender) { - if (sender != NULL) { - - } else { - - } - sender_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), sender); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessageEvent.sender) -} - -// uint32 language = 3; -inline void ChannelMessageEvent::clear_language() { - language_ = 0u; -} -inline ::google::protobuf::uint32 ChannelMessageEvent::language() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.language) - return language_; -} -inline void ChannelMessageEvent::set_language(::google::protobuf::uint32 value) { - - language_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.language) -} - -// uint32 chan_num = 4; -inline void ChannelMessageEvent::clear_chan_num() { - chan_num_ = 0u; -} -inline ::google::protobuf::uint32 ChannelMessageEvent::chan_num() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.chan_num) - return chan_num_; -} -inline void ChannelMessageEvent::set_chan_num(::google::protobuf::uint32 value) { - - chan_num_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.chan_num) -} - -// uint32 cm_unknown4 = 5; -inline void ChannelMessageEvent::clear_cm_unknown4() { - cm_unknown4_ = 0u; -} -inline ::google::protobuf::uint32 ChannelMessageEvent::cm_unknown4() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.cm_unknown4) - return cm_unknown4_; -} -inline void ChannelMessageEvent::set_cm_unknown4(::google::protobuf::uint32 value) { - - cm_unknown4_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.cm_unknown4) -} - -// uint32 skill_in_language = 6; -inline void ChannelMessageEvent::clear_skill_in_language() { - skill_in_language_ = 0u; -} -inline ::google::protobuf::uint32 ChannelMessageEvent::skill_in_language() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.skill_in_language) - return skill_in_language_; -} -inline void ChannelMessageEvent::set_skill_in_language(::google::protobuf::uint32 value) { - - skill_in_language_ = value; - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.skill_in_language) -} - -// string message = 7; -inline void ChannelMessageEvent::clear_message() { - message_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& ChannelMessageEvent::message() const { - // @@protoc_insertion_point(field_get:eqproto.ChannelMessageEvent.message) - return message_.GetNoArena(); -} -inline void ChannelMessageEvent::set_message(const ::std::string& value) { - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.ChannelMessageEvent.message) -} -#if LANG_CXX11 -inline void ChannelMessageEvent::set_message(::std::string&& value) { - - message_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.ChannelMessageEvent.message) -} -#endif -inline void ChannelMessageEvent::set_message(const char* value) { - GOOGLE_DCHECK(value != NULL); - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.ChannelMessageEvent.message) -} -inline void ChannelMessageEvent::set_message(const char* value, size_t size) { - - message_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.ChannelMessageEvent.message) -} -inline ::std::string* ChannelMessageEvent::mutable_message() { - - // @@protoc_insertion_point(field_mutable:eqproto.ChannelMessageEvent.message) - return message_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* ChannelMessageEvent::release_message() { - // @@protoc_insertion_point(field_release:eqproto.ChannelMessageEvent.message) - - return message_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void ChannelMessageEvent::set_allocated_message(::std::string* message) { - if (message != NULL) { - - } else { - - } - message_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), message); - // @@protoc_insertion_point(field_set_allocated:eqproto.ChannelMessageEvent.message) -} - -// ------------------------------------------------------------------- - -// WearChangeEvent - -// uint32 spawn_id = 1; -inline void WearChangeEvent::clear_spawn_id() { - spawn_id_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::spawn_id() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.spawn_id) - return spawn_id_; -} -inline void WearChangeEvent::set_spawn_id(::google::protobuf::uint32 value) { - - spawn_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.spawn_id) -} - -// uint32 material = 2; -inline void WearChangeEvent::clear_material() { - material_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::material() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.material) - return material_; -} -inline void WearChangeEvent::set_material(::google::protobuf::uint32 value) { - - material_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.material) -} - -// uint32 unknown06 = 3; -inline void WearChangeEvent::clear_unknown06() { - unknown06_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::unknown06() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.unknown06) - return unknown06_; -} -inline void WearChangeEvent::set_unknown06(::google::protobuf::uint32 value) { - - unknown06_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.unknown06) -} - -// uint32 elite_material = 4; -inline void WearChangeEvent::clear_elite_material() { - elite_material_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::elite_material() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.elite_material) - return elite_material_; -} -inline void WearChangeEvent::set_elite_material(::google::protobuf::uint32 value) { - - elite_material_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.elite_material) -} - -// uint32 hero_forge_model = 5; -inline void WearChangeEvent::clear_hero_forge_model() { - hero_forge_model_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::hero_forge_model() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.hero_forge_model) - return hero_forge_model_; -} -inline void WearChangeEvent::set_hero_forge_model(::google::protobuf::uint32 value) { - - hero_forge_model_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.hero_forge_model) -} - -// uint32 unknown18 = 6; -inline void WearChangeEvent::clear_unknown18() { - unknown18_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::unknown18() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.unknown18) - return unknown18_; -} -inline void WearChangeEvent::set_unknown18(::google::protobuf::uint32 value) { - - unknown18_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.unknown18) -} - -// .eqproto.Tint color = 7; -inline bool WearChangeEvent::has_color() const { - return this != internal_default_instance() && color_ != NULL; -} -inline void WearChangeEvent::clear_color() { - if (GetArenaNoVirtual() == NULL && color_ != NULL) { - delete color_; - } - color_ = NULL; -} -inline const ::eqproto::Tint& WearChangeEvent::color() const { - const ::eqproto::Tint* p = color_; - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.color) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_Tint_default_instance_); -} -inline ::eqproto::Tint* WearChangeEvent::release_color() { - // @@protoc_insertion_point(field_release:eqproto.WearChangeEvent.color) - - ::eqproto::Tint* temp = color_; - color_ = NULL; - return temp; -} -inline ::eqproto::Tint* WearChangeEvent::mutable_color() { - - if (color_ == NULL) { - color_ = new ::eqproto::Tint; - } - // @@protoc_insertion_point(field_mutable:eqproto.WearChangeEvent.color) - return color_; -} -inline void WearChangeEvent::set_allocated_color(::eqproto::Tint* color) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete color_; - } - if (color) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - color = ::google::protobuf::internal::GetOwnedMessage( - message_arena, color, submessage_arena); - } - - } else { - - } - color_ = color; - // @@protoc_insertion_point(field_set_allocated:eqproto.WearChangeEvent.color) -} - -// uint32 wear_slot_id = 8; -inline void WearChangeEvent::clear_wear_slot_id() { - wear_slot_id_ = 0u; -} -inline ::google::protobuf::uint32 WearChangeEvent::wear_slot_id() const { - // @@protoc_insertion_point(field_get:eqproto.WearChangeEvent.wear_slot_id) - return wear_slot_id_; -} -inline void WearChangeEvent::set_wear_slot_id(::google::protobuf::uint32 value) { - - wear_slot_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.WearChangeEvent.wear_slot_id) -} - -// ------------------------------------------------------------------- - -// DeleteSpawnEvent - -// uint32 spawn_id = 1; -inline void DeleteSpawnEvent::clear_spawn_id() { - spawn_id_ = 0u; -} -inline ::google::protobuf::uint32 DeleteSpawnEvent::spawn_id() const { - // @@protoc_insertion_point(field_get:eqproto.DeleteSpawnEvent.spawn_id) - return spawn_id_; -} -inline void DeleteSpawnEvent::set_spawn_id(::google::protobuf::uint32 value) { - - spawn_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeleteSpawnEvent.spawn_id) -} - -// uint32 decay = 2; -inline void DeleteSpawnEvent::clear_decay() { - decay_ = 0u; -} -inline ::google::protobuf::uint32 DeleteSpawnEvent::decay() const { - // @@protoc_insertion_point(field_get:eqproto.DeleteSpawnEvent.decay) - return decay_; -} -inline void DeleteSpawnEvent::set_decay(::google::protobuf::uint32 value) { - - decay_ = value; - // @@protoc_insertion_point(field_set:eqproto.DeleteSpawnEvent.decay) -} - -// ------------------------------------------------------------------- - -// HPEvent - -// uint32 spawn_id = 1; -inline void HPEvent::clear_spawn_id() { - spawn_id_ = 0u; -} -inline ::google::protobuf::uint32 HPEvent::spawn_id() const { - // @@protoc_insertion_point(field_get:eqproto.HPEvent.spawn_id) - return spawn_id_; -} -inline void HPEvent::set_spawn_id(::google::protobuf::uint32 value) { - - spawn_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.HPEvent.spawn_id) -} - -// uint32 cur_hp = 2; -inline void HPEvent::clear_cur_hp() { - cur_hp_ = 0u; -} -inline ::google::protobuf::uint32 HPEvent::cur_hp() const { - // @@protoc_insertion_point(field_get:eqproto.HPEvent.cur_hp) - return cur_hp_; -} -inline void HPEvent::set_cur_hp(::google::protobuf::uint32 value) { - - cur_hp_ = value; - // @@protoc_insertion_point(field_set:eqproto.HPEvent.cur_hp) -} - -// uint32 max_hp = 3; -inline void HPEvent::clear_max_hp() { - max_hp_ = 0u; -} -inline ::google::protobuf::uint32 HPEvent::max_hp() const { - // @@protoc_insertion_point(field_get:eqproto.HPEvent.max_hp) - return max_hp_; -} -inline void HPEvent::set_max_hp(::google::protobuf::uint32 value) { - - max_hp_ = value; - // @@protoc_insertion_point(field_set:eqproto.HPEvent.max_hp) -} - -// ------------------------------------------------------------------- - -// PlayerPositionUpdateEvent - -// uint32 spawn_id = 1; -inline void PlayerPositionUpdateEvent::clear_spawn_id() { - spawn_id_ = 0u; -} -inline ::google::protobuf::uint32 PlayerPositionUpdateEvent::spawn_id() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.spawn_id) - return spawn_id_; -} -inline void PlayerPositionUpdateEvent::set_spawn_id(::google::protobuf::uint32 value) { - - spawn_id_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.spawn_id) -} - -// int32 delta_heading = 2; -inline void PlayerPositionUpdateEvent::clear_delta_heading() { - delta_heading_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::delta_heading() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.delta_heading) - return delta_heading_; -} -inline void PlayerPositionUpdateEvent::set_delta_heading(::google::protobuf::int32 value) { - - delta_heading_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.delta_heading) -} - -// int32 x_pos = 3; -inline void PlayerPositionUpdateEvent::clear_x_pos() { - x_pos_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::x_pos() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.x_pos) - return x_pos_; -} -inline void PlayerPositionUpdateEvent::set_x_pos(::google::protobuf::int32 value) { - - x_pos_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.x_pos) -} - -// int32 padding0002 = 4; -inline void PlayerPositionUpdateEvent::clear_padding0002() { - padding0002_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::padding0002() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.padding0002) - return padding0002_; -} -inline void PlayerPositionUpdateEvent::set_padding0002(::google::protobuf::int32 value) { - - padding0002_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.padding0002) -} - -// int32 y_pos = 5; -inline void PlayerPositionUpdateEvent::clear_y_pos() { - y_pos_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::y_pos() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.y_pos) - return y_pos_; -} -inline void PlayerPositionUpdateEvent::set_y_pos(::google::protobuf::int32 value) { - - y_pos_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.y_pos) -} - -// int32 animation = 6; -inline void PlayerPositionUpdateEvent::clear_animation() { - animation_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::animation() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.animation) - return animation_; -} -inline void PlayerPositionUpdateEvent::set_animation(::google::protobuf::int32 value) { - - animation_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.animation) -} - -// int32 padding0006 = 7; -inline void PlayerPositionUpdateEvent::clear_padding0006() { - padding0006_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::padding0006() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.padding0006) - return padding0006_; -} -inline void PlayerPositionUpdateEvent::set_padding0006(::google::protobuf::int32 value) { - - padding0006_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.padding0006) -} - -// int32 z_pos = 8; -inline void PlayerPositionUpdateEvent::clear_z_pos() { - z_pos_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::z_pos() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.z_pos) - return z_pos_; -} -inline void PlayerPositionUpdateEvent::set_z_pos(::google::protobuf::int32 value) { - - z_pos_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.z_pos) -} - -// int32 delta_y = 9; -inline void PlayerPositionUpdateEvent::clear_delta_y() { - delta_y_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::delta_y() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.delta_y) - return delta_y_; -} -inline void PlayerPositionUpdateEvent::set_delta_y(::google::protobuf::int32 value) { - - delta_y_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.delta_y) -} - -// int32 delta_x = 10; -inline void PlayerPositionUpdateEvent::clear_delta_x() { - delta_x_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::delta_x() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.delta_x) - return delta_x_; -} -inline void PlayerPositionUpdateEvent::set_delta_x(::google::protobuf::int32 value) { - - delta_x_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.delta_x) -} - -// int32 heading = 11; -inline void PlayerPositionUpdateEvent::clear_heading() { - heading_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::heading() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.heading) - return heading_; -} -inline void PlayerPositionUpdateEvent::set_heading(::google::protobuf::int32 value) { - - heading_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.heading) -} - -// int32 padding0014 = 12; -inline void PlayerPositionUpdateEvent::clear_padding0014() { - padding0014_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::padding0014() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.padding0014) - return padding0014_; -} -inline void PlayerPositionUpdateEvent::set_padding0014(::google::protobuf::int32 value) { - - padding0014_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.padding0014) -} - -// int32 delta_z = 13; -inline void PlayerPositionUpdateEvent::clear_delta_z() { - delta_z_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::delta_z() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.delta_z) - return delta_z_; -} -inline void PlayerPositionUpdateEvent::set_delta_z(::google::protobuf::int32 value) { - - delta_z_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.delta_z) -} - -// int32 padding0018 = 14; -inline void PlayerPositionUpdateEvent::clear_padding0018() { - padding0018_ = 0; -} -inline ::google::protobuf::int32 PlayerPositionUpdateEvent::padding0018() const { - // @@protoc_insertion_point(field_get:eqproto.PlayerPositionUpdateEvent.padding0018) - return padding0018_; -} -inline void PlayerPositionUpdateEvent::set_padding0018(::google::protobuf::int32 value) { - - padding0018_ = value; - // @@protoc_insertion_point(field_set:eqproto.PlayerPositionUpdateEvent.padding0018) -} - -// ------------------------------------------------------------------- - -// AnimationEvent - -// uint32 spawnid = 1; -inline void AnimationEvent::clear_spawnid() { - spawnid_ = 0u; -} -inline ::google::protobuf::uint32 AnimationEvent::spawnid() const { - // @@protoc_insertion_point(field_get:eqproto.AnimationEvent.spawnid) - return spawnid_; -} -inline void AnimationEvent::set_spawnid(::google::protobuf::uint32 value) { - - spawnid_ = value; - // @@protoc_insertion_point(field_set:eqproto.AnimationEvent.spawnid) -} - -// uint32 speed = 2; -inline void AnimationEvent::clear_speed() { - speed_ = 0u; -} -inline ::google::protobuf::uint32 AnimationEvent::speed() const { - // @@protoc_insertion_point(field_get:eqproto.AnimationEvent.speed) - return speed_; -} -inline void AnimationEvent::set_speed(::google::protobuf::uint32 value) { - - speed_ = value; - // @@protoc_insertion_point(field_set:eqproto.AnimationEvent.speed) -} - -// uint32 action = 3; -inline void AnimationEvent::clear_action() { - action_ = 0u; -} -inline ::google::protobuf::uint32 AnimationEvent::action() const { - // @@protoc_insertion_point(field_get:eqproto.AnimationEvent.action) - return action_; -} -inline void AnimationEvent::set_action(::google::protobuf::uint32 value) { - - action_ = value; - // @@protoc_insertion_point(field_set:eqproto.AnimationEvent.action) -} - -// ------------------------------------------------------------------- - -// SpawnEvent - -// uint32 unknown0000 = 1; -inline void SpawnEvent::clear_unknown0000() { - unknown0000_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0000() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0000) - return unknown0000_; -} -inline void SpawnEvent::set_unknown0000(::google::protobuf::uint32 value) { - - unknown0000_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0000) -} - -// uint32 gm = 2; -inline void SpawnEvent::clear_gm() { - gm_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::gm() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.gm) - return gm_; -} -inline void SpawnEvent::set_gm(::google::protobuf::uint32 value) { - - gm_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.gm) -} - -// uint32 unknown0003 = 3; -inline void SpawnEvent::clear_unknown0003() { - unknown0003_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0003() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0003) - return unknown0003_; -} -inline void SpawnEvent::set_unknown0003(::google::protobuf::uint32 value) { - - unknown0003_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0003) -} - -// uint32 aaitle = 4; -inline void SpawnEvent::clear_aaitle() { - aaitle_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::aaitle() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.aaitle) - return aaitle_; -} -inline void SpawnEvent::set_aaitle(::google::protobuf::uint32 value) { - - aaitle_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.aaitle) -} - -// uint32 unknown0004 = 5; -inline void SpawnEvent::clear_unknown0004() { - unknown0004_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0004() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0004) - return unknown0004_; -} -inline void SpawnEvent::set_unknown0004(::google::protobuf::uint32 value) { - - unknown0004_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0004) -} - -// uint32 anon = 6; -inline void SpawnEvent::clear_anon() { - anon_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::anon() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.anon) - return anon_; -} -inline void SpawnEvent::set_anon(::google::protobuf::uint32 value) { - - anon_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.anon) -} - -// uint32 face = 7; -inline void SpawnEvent::clear_face() { - face_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::face() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.face) - return face_; -} -inline void SpawnEvent::set_face(::google::protobuf::uint32 value) { - - face_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.face) -} - -// string name = 8; -inline void SpawnEvent::clear_name() { - name_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::name() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.name) - return name_.GetNoArena(); -} -inline void SpawnEvent::set_name(const ::std::string& value) { - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.name) -} -#if LANG_CXX11 -inline void SpawnEvent::set_name(::std::string&& value) { - - name_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.name) -} -#endif -inline void SpawnEvent::set_name(const char* value) { - GOOGLE_DCHECK(value != NULL); - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.name) -} -inline void SpawnEvent::set_name(const char* value, size_t size) { - - name_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.name) -} -inline ::std::string* SpawnEvent::mutable_name() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.name) - return name_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_name() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.name) - - return name_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_name(::std::string* name) { - if (name != NULL) { - - } else { - - } - name_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), name); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.name) -} - -// uint32 deity = 9; -inline void SpawnEvent::clear_deity() { - deity_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::deity() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.deity) - return deity_; -} -inline void SpawnEvent::set_deity(::google::protobuf::uint32 value) { - - deity_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.deity) -} - -// uint32 unknown0073 = 10; -inline void SpawnEvent::clear_unknown0073() { - unknown0073_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0073() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0073) - return unknown0073_; -} -inline void SpawnEvent::set_unknown0073(::google::protobuf::uint32 value) { - - unknown0073_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0073) -} - -// float size = 11; -inline void SpawnEvent::clear_size() { - size_ = 0; -} -inline float SpawnEvent::size() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.size) - return size_; -} -inline void SpawnEvent::set_size(float value) { - - size_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.size) -} - -// uint32 unknown0079 = 12; -inline void SpawnEvent::clear_unknown0079() { - unknown0079_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0079() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0079) - return unknown0079_; -} -inline void SpawnEvent::set_unknown0079(::google::protobuf::uint32 value) { - - unknown0079_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0079) -} - -// uint32 NPC = 13; -inline void SpawnEvent::clear_npc() { - npc_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::npc() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.NPC) - return npc_; -} -inline void SpawnEvent::set_npc(::google::protobuf::uint32 value) { - - npc_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.NPC) -} - -// uint32 invis = 14; -inline void SpawnEvent::clear_invis() { - invis_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::invis() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.invis) - return invis_; -} -inline void SpawnEvent::set_invis(::google::protobuf::uint32 value) { - - invis_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.invis) -} - -// uint32 haircolor = 15; -inline void SpawnEvent::clear_haircolor() { - haircolor_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::haircolor() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.haircolor) - return haircolor_; -} -inline void SpawnEvent::set_haircolor(::google::protobuf::uint32 value) { - - haircolor_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.haircolor) -} - -// uint32 curHp = 16; -inline void SpawnEvent::clear_curhp() { - curhp_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::curhp() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.curHp) - return curhp_; -} -inline void SpawnEvent::set_curhp(::google::protobuf::uint32 value) { - - curhp_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.curHp) -} - -// uint32 max_hp = 17; -inline void SpawnEvent::clear_max_hp() { - max_hp_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::max_hp() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.max_hp) - return max_hp_; -} -inline void SpawnEvent::set_max_hp(::google::protobuf::uint32 value) { - - max_hp_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.max_hp) -} - -// uint32 findable = 18; -inline void SpawnEvent::clear_findable() { - findable_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::findable() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.findable) - return findable_; -} -inline void SpawnEvent::set_findable(::google::protobuf::uint32 value) { - - findable_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.findable) -} - -// uint32 unknown0089 = 19; -inline void SpawnEvent::clear_unknown0089() { - unknown0089_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0089() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0089) - return unknown0089_; -} -inline void SpawnEvent::set_unknown0089(::google::protobuf::uint32 value) { - - unknown0089_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0089) -} - -// int32 deltaHeading = 20; -inline void SpawnEvent::clear_deltaheading() { - deltaheading_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::deltaheading() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.deltaHeading) - return deltaheading_; -} -inline void SpawnEvent::set_deltaheading(::google::protobuf::int32 value) { - - deltaheading_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.deltaHeading) -} - -// int32 x = 21; -inline void SpawnEvent::clear_x() { - x_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::x() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.x) - return x_; -} -inline void SpawnEvent::set_x(::google::protobuf::int32 value) { - - x_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.x) -} - -// int32 padding0054 = 22; -inline void SpawnEvent::clear_padding0054() { - padding0054_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::padding0054() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.padding0054) - return padding0054_; -} -inline void SpawnEvent::set_padding0054(::google::protobuf::int32 value) { - - padding0054_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.padding0054) -} - -// int32 y = 23; -inline void SpawnEvent::clear_y() { - y_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::y() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.y) - return y_; -} -inline void SpawnEvent::set_y(::google::protobuf::int32 value) { - - y_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.y) -} - -// int32 animation = 24; -inline void SpawnEvent::clear_animation() { - animation_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::animation() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.animation) - return animation_; -} -inline void SpawnEvent::set_animation(::google::protobuf::int32 value) { - - animation_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.animation) -} - -// int32 padding0058 = 25; -inline void SpawnEvent::clear_padding0058() { - padding0058_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::padding0058() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.padding0058) - return padding0058_; -} -inline void SpawnEvent::set_padding0058(::google::protobuf::int32 value) { - - padding0058_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.padding0058) -} - -// int32 z = 26; -inline void SpawnEvent::clear_z() { - z_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::z() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.z) - return z_; -} -inline void SpawnEvent::set_z(::google::protobuf::int32 value) { - - z_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.z) -} - -// int32 deltaY = 27; -inline void SpawnEvent::clear_deltay() { - deltay_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::deltay() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.deltaY) - return deltay_; -} -inline void SpawnEvent::set_deltay(::google::protobuf::int32 value) { - - deltay_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.deltaY) -} - -// int32 deltaX = 28; -inline void SpawnEvent::clear_deltax() { - deltax_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::deltax() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.deltaX) - return deltax_; -} -inline void SpawnEvent::set_deltax(::google::protobuf::int32 value) { - - deltax_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.deltaX) -} - -// uint32 heading = 29; -inline void SpawnEvent::clear_heading() { - heading_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::heading() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.heading) - return heading_; -} -inline void SpawnEvent::set_heading(::google::protobuf::uint32 value) { - - heading_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.heading) -} - -// int32 padding0066 = 30; -inline void SpawnEvent::clear_padding0066() { - padding0066_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::padding0066() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.padding0066) - return padding0066_; -} -inline void SpawnEvent::set_padding0066(::google::protobuf::int32 value) { - - padding0066_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.padding0066) -} - -// int32 deltaZ = 31; -inline void SpawnEvent::clear_deltaz() { - deltaz_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::deltaz() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.deltaZ) - return deltaz_; -} -inline void SpawnEvent::set_deltaz(::google::protobuf::int32 value) { - - deltaz_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.deltaZ) -} - -// int32 padding0070 = 32; -inline void SpawnEvent::clear_padding0070() { - padding0070_ = 0; -} -inline ::google::protobuf::int32 SpawnEvent::padding0070() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.padding0070) - return padding0070_; -} -inline void SpawnEvent::set_padding0070(::google::protobuf::int32 value) { - - padding0070_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.padding0070) -} - -// uint32 eyecolor1 = 33; -inline void SpawnEvent::clear_eyecolor1() { - eyecolor1_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::eyecolor1() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.eyecolor1) - return eyecolor1_; -} -inline void SpawnEvent::set_eyecolor1(::google::protobuf::uint32 value) { - - eyecolor1_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.eyecolor1) -} - -// uint32 unknown0115 = 34; -inline void SpawnEvent::clear_unknown0115() { - unknown0115_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0115() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0115) - return unknown0115_; -} -inline void SpawnEvent::set_unknown0115(::google::protobuf::uint32 value) { - - unknown0115_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0115) -} - -// uint32 StandState = 35; -inline void SpawnEvent::clear_standstate() { - standstate_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::standstate() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.StandState) - return standstate_; -} -inline void SpawnEvent::set_standstate(::google::protobuf::uint32 value) { - - standstate_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.StandState) -} - -// uint32 drakkin_heritage = 36; -inline void SpawnEvent::clear_drakkin_heritage() { - drakkin_heritage_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::drakkin_heritage() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.drakkin_heritage) - return drakkin_heritage_; -} -inline void SpawnEvent::set_drakkin_heritage(::google::protobuf::uint32 value) { - - drakkin_heritage_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.drakkin_heritage) -} - -// uint32 drakkin_tattoo = 37; -inline void SpawnEvent::clear_drakkin_tattoo() { - drakkin_tattoo_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::drakkin_tattoo() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.drakkin_tattoo) - return drakkin_tattoo_; -} -inline void SpawnEvent::set_drakkin_tattoo(::google::protobuf::uint32 value) { - - drakkin_tattoo_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.drakkin_tattoo) -} - -// uint32 drakkin_details = 38; -inline void SpawnEvent::clear_drakkin_details() { - drakkin_details_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::drakkin_details() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.drakkin_details) - return drakkin_details_; -} -inline void SpawnEvent::set_drakkin_details(::google::protobuf::uint32 value) { - - drakkin_details_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.drakkin_details) -} - -// uint32 showhelm = 39; -inline void SpawnEvent::clear_showhelm() { - showhelm_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::showhelm() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.showhelm) - return showhelm_; -} -inline void SpawnEvent::set_showhelm(::google::protobuf::uint32 value) { - - showhelm_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.showhelm) -} - -// uint32 unknown0140 = 40; -inline void SpawnEvent::clear_unknown0140() { - unknown0140_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0140() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0140) - return unknown0140_; -} -inline void SpawnEvent::set_unknown0140(::google::protobuf::uint32 value) { - - unknown0140_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0140) -} - -// uint32 is_npc = 41; -inline void SpawnEvent::clear_is_npc() { - is_npc_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::is_npc() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.is_npc) - return is_npc_; -} -inline void SpawnEvent::set_is_npc(::google::protobuf::uint32 value) { - - is_npc_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.is_npc) -} - -// uint32 hairstyle = 42; -inline void SpawnEvent::clear_hairstyle() { - hairstyle_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::hairstyle() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.hairstyle) - return hairstyle_; -} -inline void SpawnEvent::set_hairstyle(::google::protobuf::uint32 value) { - - hairstyle_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.hairstyle) -} - -// uint32 beard = 43; -inline void SpawnEvent::clear_beard() { - beard_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::beard() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.beard) - return beard_; -} -inline void SpawnEvent::set_beard(::google::protobuf::uint32 value) { - - beard_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.beard) -} - -// uint32 unknown0147 = 44; -inline void SpawnEvent::clear_unknown0147() { - unknown0147_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0147() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0147) - return unknown0147_; -} -inline void SpawnEvent::set_unknown0147(::google::protobuf::uint32 value) { - - unknown0147_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0147) -} - -// uint32 level = 45; -inline void SpawnEvent::clear_level() { - level_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::level() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.level) - return level_; -} -inline void SpawnEvent::set_level(::google::protobuf::uint32 value) { - - level_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.level) -} - -// uint32 PlayerState = 46; -inline void SpawnEvent::clear_playerstate() { - playerstate_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::playerstate() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.PlayerState) - return playerstate_; -} -inline void SpawnEvent::set_playerstate(::google::protobuf::uint32 value) { - - playerstate_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.PlayerState) -} - -// uint32 beardcolor = 47; -inline void SpawnEvent::clear_beardcolor() { - beardcolor_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::beardcolor() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.beardcolor) - return beardcolor_; -} -inline void SpawnEvent::set_beardcolor(::google::protobuf::uint32 value) { - - beardcolor_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.beardcolor) -} - -// string suffix = 48; -inline void SpawnEvent::clear_suffix() { - suffix_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::suffix() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.suffix) - return suffix_.GetNoArena(); -} -inline void SpawnEvent::set_suffix(const ::std::string& value) { - - suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.suffix) -} -#if LANG_CXX11 -inline void SpawnEvent::set_suffix(::std::string&& value) { - - suffix_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.suffix) -} -#endif -inline void SpawnEvent::set_suffix(const char* value) { - GOOGLE_DCHECK(value != NULL); - - suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.suffix) -} -inline void SpawnEvent::set_suffix(const char* value, size_t size) { - - suffix_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.suffix) -} -inline ::std::string* SpawnEvent::mutable_suffix() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.suffix) - return suffix_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_suffix() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.suffix) - - return suffix_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_suffix(::std::string* suffix) { - if (suffix != NULL) { - - } else { - - } - suffix_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), suffix); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.suffix) -} - -// uint32 petOwnerId = 49; -inline void SpawnEvent::clear_petownerid() { - petownerid_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::petownerid() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.petOwnerId) - return petownerid_; -} -inline void SpawnEvent::set_petownerid(::google::protobuf::uint32 value) { - - petownerid_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.petOwnerId) -} - -// uint32 guildrank = 50; -inline void SpawnEvent::clear_guildrank() { - guildrank_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::guildrank() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.guildrank) - return guildrank_; -} -inline void SpawnEvent::set_guildrank(::google::protobuf::uint32 value) { - - guildrank_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.guildrank) -} - -// uint32 unknown0194 = 51; -inline void SpawnEvent::clear_unknown0194() { - unknown0194_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0194() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0194) - return unknown0194_; -} -inline void SpawnEvent::set_unknown0194(::google::protobuf::uint32 value) { - - unknown0194_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0194) -} - -// .eqproto.TextureProfile equipment = 52; -inline bool SpawnEvent::has_equipment() const { - return this != internal_default_instance() && equipment_ != NULL; -} -inline void SpawnEvent::clear_equipment() { - if (GetArenaNoVirtual() == NULL && equipment_ != NULL) { - delete equipment_; - } - equipment_ = NULL; -} -inline const ::eqproto::TextureProfile& SpawnEvent::equipment() const { - const ::eqproto::TextureProfile* p = equipment_; - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.equipment) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_TextureProfile_default_instance_); -} -inline ::eqproto::TextureProfile* SpawnEvent::release_equipment() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.equipment) - - ::eqproto::TextureProfile* temp = equipment_; - equipment_ = NULL; - return temp; -} -inline ::eqproto::TextureProfile* SpawnEvent::mutable_equipment() { - - if (equipment_ == NULL) { - equipment_ = new ::eqproto::TextureProfile; - } - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.equipment) - return equipment_; -} -inline void SpawnEvent::set_allocated_equipment(::eqproto::TextureProfile* equipment) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete equipment_; - } - if (equipment) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - equipment = ::google::protobuf::internal::GetOwnedMessage( - message_arena, equipment, submessage_arena); - } - - } else { - - } - equipment_ = equipment; - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.equipment) -} - -// float runspeed = 53; -inline void SpawnEvent::clear_runspeed() { - runspeed_ = 0; -} -inline float SpawnEvent::runspeed() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.runspeed) - return runspeed_; -} -inline void SpawnEvent::set_runspeed(float value) { - - runspeed_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.runspeed) -} - -// uint32 afk = 54; -inline void SpawnEvent::clear_afk() { - afk_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::afk() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.afk) - return afk_; -} -inline void SpawnEvent::set_afk(::google::protobuf::uint32 value) { - - afk_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.afk) -} - -// uint32 guildID = 55; -inline void SpawnEvent::clear_guildid() { - guildid_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::guildid() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.guildID) - return guildid_; -} -inline void SpawnEvent::set_guildid(::google::protobuf::uint32 value) { - - guildid_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.guildID) -} - -// string title = 56; -inline void SpawnEvent::clear_title() { - title_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::title() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.title) - return title_.GetNoArena(); -} -inline void SpawnEvent::set_title(const ::std::string& value) { - - title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.title) -} -#if LANG_CXX11 -inline void SpawnEvent::set_title(::std::string&& value) { - - title_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.title) -} -#endif -inline void SpawnEvent::set_title(const char* value) { - GOOGLE_DCHECK(value != NULL); - - title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.title) -} -inline void SpawnEvent::set_title(const char* value, size_t size) { - - title_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.title) -} -inline ::std::string* SpawnEvent::mutable_title() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.title) - return title_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_title() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.title) - - return title_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_title(::std::string* title) { - if (title != NULL) { - - } else { - - } - title_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), title); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.title) -} - -// uint32 unknown0274 = 57; -inline void SpawnEvent::clear_unknown0274() { - unknown0274_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0274() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0274) - return unknown0274_; -} -inline void SpawnEvent::set_unknown0274(::google::protobuf::uint32 value) { - - unknown0274_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0274) -} - -// uint32 set_to_0xFF = 58; -inline void SpawnEvent::clear_set_to_0xff() { - set_to_0xff_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::set_to_0xff() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.set_to_0xFF) - return set_to_0xff_; -} -inline void SpawnEvent::set_set_to_0xff(::google::protobuf::uint32 value) { - - set_to_0xff_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.set_to_0xFF) -} - -// uint32 helm = 59; -inline void SpawnEvent::clear_helm() { - helm_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::helm() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.helm) - return helm_; -} -inline void SpawnEvent::set_helm(::google::protobuf::uint32 value) { - - helm_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.helm) -} - -// uint32 race = 60; -inline void SpawnEvent::clear_race() { - race_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::race() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.race) - return race_; -} -inline void SpawnEvent::set_race(::google::protobuf::uint32 value) { - - race_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.race) -} - -// uint32 unknown0288 = 61; -inline void SpawnEvent::clear_unknown0288() { - unknown0288_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0288() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0288) - return unknown0288_; -} -inline void SpawnEvent::set_unknown0288(::google::protobuf::uint32 value) { - - unknown0288_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0288) -} - -// string lastName = 62; -inline void SpawnEvent::clear_lastname() { - lastname_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::lastname() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.lastName) - return lastname_.GetNoArena(); -} -inline void SpawnEvent::set_lastname(const ::std::string& value) { - - lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.lastName) -} -#if LANG_CXX11 -inline void SpawnEvent::set_lastname(::std::string&& value) { - - lastname_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.lastName) -} -#endif -inline void SpawnEvent::set_lastname(const char* value) { - GOOGLE_DCHECK(value != NULL); - - lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.lastName) -} -inline void SpawnEvent::set_lastname(const char* value, size_t size) { - - lastname_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.lastName) -} -inline ::std::string* SpawnEvent::mutable_lastname() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.lastName) - return lastname_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_lastname() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.lastName) - - return lastname_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_lastname(::std::string* lastname) { - if (lastname != NULL) { - - } else { - - } - lastname_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), lastname); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.lastName) -} - -// float walkspeed = 63; -inline void SpawnEvent::clear_walkspeed() { - walkspeed_ = 0; -} -inline float SpawnEvent::walkspeed() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.walkspeed) - return walkspeed_; -} -inline void SpawnEvent::set_walkspeed(float value) { - - walkspeed_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.walkspeed) -} - -// uint32 unknown0328 = 64; -inline void SpawnEvent::clear_unknown0328() { - unknown0328_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0328() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0328) - return unknown0328_; -} -inline void SpawnEvent::set_unknown0328(::google::protobuf::uint32 value) { - - unknown0328_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0328) -} - -// uint32 is_pet = 65; -inline void SpawnEvent::clear_is_pet() { - is_pet_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::is_pet() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.is_pet) - return is_pet_; -} -inline void SpawnEvent::set_is_pet(::google::protobuf::uint32 value) { - - is_pet_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.is_pet) -} - -// uint32 light = 66; -inline void SpawnEvent::clear_light() { - light_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::light() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.light) - return light_; -} -inline void SpawnEvent::set_light(::google::protobuf::uint32 value) { - - light_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.light) -} - -// uint32 class_ = 67; -inline void SpawnEvent::clear_class_() { - class__ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::class_() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.class_) - return class__; -} -inline void SpawnEvent::set_class_(::google::protobuf::uint32 value) { - - class__ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.class_) -} - -// uint32 eyecolor2 = 68; -inline void SpawnEvent::clear_eyecolor2() { - eyecolor2_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::eyecolor2() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.eyecolor2) - return eyecolor2_; -} -inline void SpawnEvent::set_eyecolor2(::google::protobuf::uint32 value) { - - eyecolor2_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.eyecolor2) -} - -// uint32 flymode = 69; -inline void SpawnEvent::clear_flymode() { - flymode_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::flymode() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.flymode) - return flymode_; -} -inline void SpawnEvent::set_flymode(::google::protobuf::uint32 value) { - - flymode_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.flymode) -} - -// uint32 gender = 70; -inline void SpawnEvent::clear_gender() { - gender_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::gender() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.gender) - return gender_; -} -inline void SpawnEvent::set_gender(::google::protobuf::uint32 value) { - - gender_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.gender) -} - -// uint32 bodytype = 71; -inline void SpawnEvent::clear_bodytype() { - bodytype_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::bodytype() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.bodytype) - return bodytype_; -} -inline void SpawnEvent::set_bodytype(::google::protobuf::uint32 value) { - - bodytype_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.bodytype) -} - -// uint32 unknown0336 = 72; -inline void SpawnEvent::clear_unknown0336() { - unknown0336_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0336() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0336) - return unknown0336_; -} -inline void SpawnEvent::set_unknown0336(::google::protobuf::uint32 value) { - - unknown0336_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0336) -} - -// uint32 equip_chest2 = 73; -inline void SpawnEvent::clear_equip_chest2() { - equip_chest2_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::equip_chest2() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.equip_chest2) - return equip_chest2_; -} -inline void SpawnEvent::set_equip_chest2(::google::protobuf::uint32 value) { - - equip_chest2_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.equip_chest2) -} - -// uint32 mount_color = 74; -inline void SpawnEvent::clear_mount_color() { - mount_color_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::mount_color() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.mount_color) - return mount_color_; -} -inline void SpawnEvent::set_mount_color(::google::protobuf::uint32 value) { - - mount_color_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.mount_color) -} - -// uint32 spawnId = 75; -inline void SpawnEvent::clear_spawnid() { - spawnid_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::spawnid() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.spawnId) - return spawnid_; -} -inline void SpawnEvent::set_spawnid(::google::protobuf::uint32 value) { - - spawnid_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.spawnId) -} - -// uint32 unknown0344 = 76; -inline void SpawnEvent::clear_unknown0344() { - unknown0344_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::unknown0344() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.unknown0344) - return unknown0344_; -} -inline void SpawnEvent::set_unknown0344(::google::protobuf::uint32 value) { - - unknown0344_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.unknown0344) -} - -// uint32 IsMercenary = 77; -inline void SpawnEvent::clear_ismercenary() { - ismercenary_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::ismercenary() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.IsMercenary) - return ismercenary_; -} -inline void SpawnEvent::set_ismercenary(::google::protobuf::uint32 value) { - - ismercenary_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.IsMercenary) -} - -// .eqproto.TintProfile equipment_tint = 78; -inline bool SpawnEvent::has_equipment_tint() const { - return this != internal_default_instance() && equipment_tint_ != NULL; -} -inline void SpawnEvent::clear_equipment_tint() { - if (GetArenaNoVirtual() == NULL && equipment_tint_ != NULL) { - delete equipment_tint_; - } - equipment_tint_ = NULL; -} -inline const ::eqproto::TintProfile& SpawnEvent::equipment_tint() const { - const ::eqproto::TintProfile* p = equipment_tint_; - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.equipment_tint) - return p != NULL ? *p : *reinterpret_cast( - &::eqproto::_TintProfile_default_instance_); -} -inline ::eqproto::TintProfile* SpawnEvent::release_equipment_tint() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.equipment_tint) - - ::eqproto::TintProfile* temp = equipment_tint_; - equipment_tint_ = NULL; - return temp; -} -inline ::eqproto::TintProfile* SpawnEvent::mutable_equipment_tint() { - - if (equipment_tint_ == NULL) { - equipment_tint_ = new ::eqproto::TintProfile; - } - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.equipment_tint) - return equipment_tint_; -} -inline void SpawnEvent::set_allocated_equipment_tint(::eqproto::TintProfile* equipment_tint) { - ::google::protobuf::Arena* message_arena = GetArenaNoVirtual(); - if (message_arena == NULL) { - delete equipment_tint_; - } - if (equipment_tint) { - ::google::protobuf::Arena* submessage_arena = NULL; - if (message_arena != submessage_arena) { - equipment_tint = ::google::protobuf::internal::GetOwnedMessage( - message_arena, equipment_tint, submessage_arena); - } - - } else { - - } - equipment_tint_ = equipment_tint; - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.equipment_tint) -} - -// uint32 lfg = 79; -inline void SpawnEvent::clear_lfg() { - lfg_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::lfg() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.lfg) - return lfg_; -} -inline void SpawnEvent::set_lfg(::google::protobuf::uint32 value) { - - lfg_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.lfg) -} - -// bool DestructibleObject = 80; -inline void SpawnEvent::clear_destructibleobject() { - destructibleobject_ = false; -} -inline bool SpawnEvent::destructibleobject() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleObject) - return destructibleobject_; -} -inline void SpawnEvent::set_destructibleobject(bool value) { - - destructibleobject_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleObject) -} - -// string DestructibleModel = 82; -inline void SpawnEvent::clear_destructiblemodel() { - destructiblemodel_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::destructiblemodel() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleModel) - return destructiblemodel_.GetNoArena(); -} -inline void SpawnEvent::set_destructiblemodel(const ::std::string& value) { - - destructiblemodel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleModel) -} -#if LANG_CXX11 -inline void SpawnEvent::set_destructiblemodel(::std::string&& value) { - - destructiblemodel_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.DestructibleModel) -} -#endif -inline void SpawnEvent::set_destructiblemodel(const char* value) { - GOOGLE_DCHECK(value != NULL); - - destructiblemodel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.DestructibleModel) -} -inline void SpawnEvent::set_destructiblemodel(const char* value, size_t size) { - - destructiblemodel_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.DestructibleModel) -} -inline ::std::string* SpawnEvent::mutable_destructiblemodel() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.DestructibleModel) - return destructiblemodel_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_destructiblemodel() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.DestructibleModel) - - return destructiblemodel_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_destructiblemodel(::std::string* destructiblemodel) { - if (destructiblemodel != NULL) { - - } else { - - } - destructiblemodel_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), destructiblemodel); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.DestructibleModel) -} - -// string DestructibleName2 = 83; -inline void SpawnEvent::clear_destructiblename2() { - destructiblename2_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::destructiblename2() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleName2) - return destructiblename2_.GetNoArena(); -} -inline void SpawnEvent::set_destructiblename2(const ::std::string& value) { - - destructiblename2_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleName2) -} -#if LANG_CXX11 -inline void SpawnEvent::set_destructiblename2(::std::string&& value) { - - destructiblename2_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.DestructibleName2) -} -#endif -inline void SpawnEvent::set_destructiblename2(const char* value) { - GOOGLE_DCHECK(value != NULL); - - destructiblename2_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.DestructibleName2) -} -inline void SpawnEvent::set_destructiblename2(const char* value, size_t size) { - - destructiblename2_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.DestructibleName2) -} -inline ::std::string* SpawnEvent::mutable_destructiblename2() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.DestructibleName2) - return destructiblename2_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_destructiblename2() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.DestructibleName2) - - return destructiblename2_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_destructiblename2(::std::string* destructiblename2) { - if (destructiblename2 != NULL) { - - } else { - - } - destructiblename2_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), destructiblename2); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.DestructibleName2) -} - -// string DestructibleString = 84; -inline void SpawnEvent::clear_destructiblestring() { - destructiblestring_.ClearToEmptyNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline const ::std::string& SpawnEvent::destructiblestring() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleString) - return destructiblestring_.GetNoArena(); -} -inline void SpawnEvent::set_destructiblestring(const ::std::string& value) { - - destructiblestring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), value); - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleString) -} -#if LANG_CXX11 -inline void SpawnEvent::set_destructiblestring(::std::string&& value) { - - destructiblestring_.SetNoArena( - &::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::move(value)); - // @@protoc_insertion_point(field_set_rvalue:eqproto.SpawnEvent.DestructibleString) -} -#endif -inline void SpawnEvent::set_destructiblestring(const char* value) { - GOOGLE_DCHECK(value != NULL); - - destructiblestring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), ::std::string(value)); - // @@protoc_insertion_point(field_set_char:eqproto.SpawnEvent.DestructibleString) -} -inline void SpawnEvent::set_destructiblestring(const char* value, size_t size) { - - destructiblestring_.SetNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), - ::std::string(reinterpret_cast(value), size)); - // @@protoc_insertion_point(field_set_pointer:eqproto.SpawnEvent.DestructibleString) -} -inline ::std::string* SpawnEvent::mutable_destructiblestring() { - - // @@protoc_insertion_point(field_mutable:eqproto.SpawnEvent.DestructibleString) - return destructiblestring_.MutableNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline ::std::string* SpawnEvent::release_destructiblestring() { - // @@protoc_insertion_point(field_release:eqproto.SpawnEvent.DestructibleString) - - return destructiblestring_.ReleaseNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited()); -} -inline void SpawnEvent::set_allocated_destructiblestring(::std::string* destructiblestring) { - if (destructiblestring != NULL) { - - } else { - - } - destructiblestring_.SetAllocatedNoArena(&::google::protobuf::internal::GetEmptyStringAlreadyInited(), destructiblestring); - // @@protoc_insertion_point(field_set_allocated:eqproto.SpawnEvent.DestructibleString) -} - -// uint32 DestructibleAppearance = 85; -inline void SpawnEvent::clear_destructibleappearance() { - destructibleappearance_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleappearance() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleAppearance) - return destructibleappearance_; -} -inline void SpawnEvent::set_destructibleappearance(::google::protobuf::uint32 value) { - - destructibleappearance_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleAppearance) -} - -// uint32 DestructibleUnk1 = 86; -inline void SpawnEvent::clear_destructibleunk1() { - destructibleunk1_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk1() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk1) - return destructibleunk1_; -} -inline void SpawnEvent::set_destructibleunk1(::google::protobuf::uint32 value) { - - destructibleunk1_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk1) -} - -// uint32 DestructibleID1 = 87; -inline void SpawnEvent::clear_destructibleid1() { - destructibleid1_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleid1() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleID1) - return destructibleid1_; -} -inline void SpawnEvent::set_destructibleid1(::google::protobuf::uint32 value) { - - destructibleid1_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleID1) -} - -// uint32 DestructibleID2 = 88; -inline void SpawnEvent::clear_destructibleid2() { - destructibleid2_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleid2() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleID2) - return destructibleid2_; -} -inline void SpawnEvent::set_destructibleid2(::google::protobuf::uint32 value) { - - destructibleid2_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleID2) -} - -// uint32 DestructibleID3 = 89; -inline void SpawnEvent::clear_destructibleid3() { - destructibleid3_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleid3() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleID3) - return destructibleid3_; -} -inline void SpawnEvent::set_destructibleid3(::google::protobuf::uint32 value) { - - destructibleid3_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleID3) -} - -// uint32 DestructibleID4 = 90; -inline void SpawnEvent::clear_destructibleid4() { - destructibleid4_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleid4() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleID4) - return destructibleid4_; -} -inline void SpawnEvent::set_destructibleid4(::google::protobuf::uint32 value) { - - destructibleid4_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleID4) -} - -// uint32 DestructibleUnk2 = 91; -inline void SpawnEvent::clear_destructibleunk2() { - destructibleunk2_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk2() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk2) - return destructibleunk2_; -} -inline void SpawnEvent::set_destructibleunk2(::google::protobuf::uint32 value) { - - destructibleunk2_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk2) -} - -// uint32 DestructibleUnk3 = 92; -inline void SpawnEvent::clear_destructibleunk3() { - destructibleunk3_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk3() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk3) - return destructibleunk3_; -} -inline void SpawnEvent::set_destructibleunk3(::google::protobuf::uint32 value) { - - destructibleunk3_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk3) -} - -// uint32 DestructibleUnk4 = 93; -inline void SpawnEvent::clear_destructibleunk4() { - destructibleunk4_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk4() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk4) - return destructibleunk4_; -} -inline void SpawnEvent::set_destructibleunk4(::google::protobuf::uint32 value) { - - destructibleunk4_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk4) -} - -// uint32 DestructibleUnk5 = 94; -inline void SpawnEvent::clear_destructibleunk5() { - destructibleunk5_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk5() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk5) - return destructibleunk5_; -} -inline void SpawnEvent::set_destructibleunk5(::google::protobuf::uint32 value) { - - destructibleunk5_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk5) -} - -// uint32 DestructibleUnk6 = 95; -inline void SpawnEvent::clear_destructibleunk6() { - destructibleunk6_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk6() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk6) - return destructibleunk6_; -} -inline void SpawnEvent::set_destructibleunk6(::google::protobuf::uint32 value) { - - destructibleunk6_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk6) -} - -// uint32 DestructibleUnk7 = 96; -inline void SpawnEvent::clear_destructibleunk7() { - destructibleunk7_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk7() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk7) - return destructibleunk7_; -} -inline void SpawnEvent::set_destructibleunk7(::google::protobuf::uint32 value) { - - destructibleunk7_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk7) -} - -// uint32 DestructibleUnk8 = 97; -inline void SpawnEvent::clear_destructibleunk8() { - destructibleunk8_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk8() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk8) - return destructibleunk8_; -} -inline void SpawnEvent::set_destructibleunk8(::google::protobuf::uint32 value) { - - destructibleunk8_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk8) -} - -// uint32 DestructibleUnk9 = 98; -inline void SpawnEvent::clear_destructibleunk9() { - destructibleunk9_ = 0u; -} -inline ::google::protobuf::uint32 SpawnEvent::destructibleunk9() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.DestructibleUnk9) - return destructibleunk9_; -} -inline void SpawnEvent::set_destructibleunk9(::google::protobuf::uint32 value) { - - destructibleunk9_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.DestructibleUnk9) -} - -// bool targetable_with_hotkey = 99; -inline void SpawnEvent::clear_targetable_with_hotkey() { - targetable_with_hotkey_ = false; -} -inline bool SpawnEvent::targetable_with_hotkey() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.targetable_with_hotkey) - return targetable_with_hotkey_; -} -inline void SpawnEvent::set_targetable_with_hotkey(bool value) { - - targetable_with_hotkey_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.targetable_with_hotkey) -} - -// bool show_name = 100; -inline void SpawnEvent::clear_show_name() { - show_name_ = false; -} -inline bool SpawnEvent::show_name() const { - // @@protoc_insertion_point(field_get:eqproto.SpawnEvent.show_name) - return show_name_; -} -inline void SpawnEvent::set_show_name(bool value) { - - show_name_ = value; - // @@protoc_insertion_point(field_set:eqproto.SpawnEvent.show_name) -} - -#ifdef __GNUC__ - #pragma GCC diagnostic pop -#endif // __GNUC__ -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - -// ------------------------------------------------------------------- - - -// @@protoc_insertion_point(namespace_scope) - -} // namespace eqproto - -namespace google { -namespace protobuf { - -template <> struct is_proto_enum< ::eqproto::OpCode> : ::google::protobuf::internal::true_type {}; -template <> -inline const EnumDescriptor* GetEnumDescriptor< ::eqproto::OpCode>() { - return ::eqproto::OpCode_descriptor(); -} - -} // namespace protobuf -} // namespace google - -// @@protoc_insertion_point(global_scope) - -#endif // PROTOBUF_message_2eproto__INCLUDED diff --git a/protobuf/build.bat b/protobuf/build.bat index 5276730da..3372d0117 100644 --- a/protobuf/build.bat +++ b/protobuf/build.bat @@ -1,7 +1,8 @@ @echo off +mkdir go\eqproto python\proto java\eqproto csharp\proto del /q ..\common\proto\* del /q go\eqproto\* -del /q python\proto\*pb2* -del /q java\eqproto\*.java -del /q csharp\proto\*.cs -protoc --cpp_out=../common/proto --go_out=go/eqproto --python_out=python/proto --csharp_out=csharp/proto --java_out=java message.proto \ No newline at end of file +del /q python\proto\* +del /q java\eqproto\* +del /q csharp\proto\* +..\dependencies\protobuf\bin\protoc --go_out=go/eqproto --python_out=python/proto --csharp_out=csharp/proto --java_out=java --proto_path=../common message.proto \ No newline at end of file diff --git a/protobuf/build.sh b/protobuf/build.sh index 24b348514..e2162dccb 100644 --- a/protobuf/build.sh +++ b/protobuf/build.sh @@ -1,5 +1,5 @@ #!/bin/bash set -e -echo "Cleaning up existing .pb* files" +echo "Cleaning up existing .pb files" rm -rf ../common/proto/* go/eqproto/* csharp/proto/*.cs java/eqproto/*.java python/proto/*pb2* -protoc --cpp_out=../common/proto --go_out=go/eqproto --python_out=python/proto --csharp_out=csharp/proto --java_out=java message.proto \ No newline at end of file +protoc --go_out=go/eqproto --python_out=python/proto --csharp_out=csharp/proto --java_out=java -I ../common/ message.proto \ No newline at end of file diff --git a/world/nats_manager.h b/world/nats_manager.h index 106ae8c49..867177c36 100644 --- a/world/nats_manager.h +++ b/world/nats_manager.h @@ -9,7 +9,7 @@ #include "../common/timer.h" #ifndef PROTO_H #define PROTO_H -#include "../common/proto/message.pb.h" +#include "../common/message.pb.h" #endif #include "../common/servertalk.h" diff --git a/zone/nats_manager.cpp b/zone/nats_manager.cpp index 11991e0ff..f59b1c4fa 100644 --- a/zone/nats_manager.cpp +++ b/zone/nats_manager.cpp @@ -13,7 +13,7 @@ #include "../common/string_util.h" #ifndef PROTO_H #define PROTO_H -#include "../common/proto/message.pb.h" +#include "../common/message.pb.h" #endif const ZoneConfig *zoneConfig;