aboutsummaryrefslogtreecommitdiff
path: root/src/shared
diff options
context:
space:
mode:
Diffstat (limited to 'src/shared')
-rw-r--r--src/shared/math.cc23
-rw-r--r--src/shared/math.hh53
-rw-r--r--src/shared/movement.cc490
-rw-r--r--src/shared/movement.hh67
-rw-r--r--src/shared/net/connection.cc1
-rw-r--r--src/shared/net/connection.hh212
-rw-r--r--src/shared/net/lib/protobuf/net.pb.cc5548
-rw-r--r--src/shared/net/lib/protobuf/net.pb.h6386
-rw-r--r--src/shared/net/lib/protobuf/net.proto123
-rw-r--r--src/shared/net/net.cc138
-rw-r--r--src/shared/net/net.hh56
-rw-r--r--src/shared/net/proto.cc55
-rw-r--r--src/shared/net/proto.hh28
-rw-r--r--src/shared/player.cc1
-rw-r--r--src/shared/player.hh46
-rw-r--r--src/shared/shared.cc57
-rw-r--r--src/shared/shared.hh120
-rw-r--r--src/shared/world.cc932
-rw-r--r--src/shared/world.hh224
19 files changed, 14560 insertions, 0 deletions
diff --git a/src/shared/math.cc b/src/shared/math.cc
new file mode 100644
index 0000000..80eba81
--- /dev/null
+++ b/src/shared/math.cc
@@ -0,0 +1,23 @@
+#include "shared/math.hh"
+
+namespace shared {
+namespace math {
+
+glm::vec3 angle_to_dir(const angles& ang) noexcept {
+ const float x = std::cos(ang.pitch) * std::cos(ang.yaw);
+ const float y = std::sin(ang.pitch);
+ const float z = std::cos(ang.pitch) * std::sin(ang.yaw);
+ return {x, y, z};
+}
+
+bool is_inside_draw(const coords& a, const coords& b,
+ const std::int32_t draw_distance) noexcept {
+ const auto x2 = (a.x - b.x) * (a.x - b.x);
+ const auto z2 = (a.z - b.z) * (a.z - b.z);
+ const auto dd2 = draw_distance * draw_distance;
+
+ return (x2 < dd2 - z2) && (z2 < dd2 - x2);
+}
+
+} // namespace math
+} // namespace shared
diff --git a/src/shared/math.hh b/src/shared/math.hh
new file mode 100644
index 0000000..5f03ab4
--- /dev/null
+++ b/src/shared/math.hh
@@ -0,0 +1,53 @@
+#ifndef SHARED_MATH_HH_
+#define SHARED_MATH_HH_
+
+#include <compare>
+
+#include <glm/glm.hpp>
+#include <glm/gtc/matrix_transform.hpp>
+#include <glm/gtc/type_ptr.hpp>
+
+namespace shared {
+namespace math {
+
+// 2D coordinates.
+struct coords {
+ std::int32_t x;
+ std::int32_t z;
+ coords operator+(const coords& c) const noexcept {
+ auto ret = *this;
+ ret.x += c.x;
+ ret.z += c.z;
+ return ret;
+ }
+ coords operator-(const coords& c) const noexcept {
+ auto ret = *this;
+ ret.x -= c.x;
+ ret.z -= c.z;
+ return ret;
+ }
+ auto operator<=>(const coords& c) const noexcept = default;
+};
+
+struct angles {
+ float pitch;
+ float yaw;
+ angles operator+(const angles& a) const noexcept {
+ auto ret = *this;
+ ret.pitch += a.pitch;
+ ret.yaw += a.yaw;
+ return ret;
+ }
+};
+
+// Returns a vector pointing in the direction of pitch + yaw.
+glm::vec3 angle_to_dir(const angles& ang) noexcept;
+
+bool is_inside_draw(const shared::math::coords& a,
+ const shared::math::coords& b,
+ const std::int32_t draw_distance) noexcept;
+
+} // namespace math
+} // namespace shared
+
+#endif
diff --git a/src/shared/movement.cc b/src/shared/movement.cc
new file mode 100644
index 0000000..985062c
--- /dev/null
+++ b/src/shared/movement.cc
@@ -0,0 +1,490 @@
+#include "shared/movement.hh"
+
+namespace shared {
+namespace movement {
+
+// Move a player into the correct neighbour chunk if they go over a border.
+static void shift_chunk(shared::player& player) noexcept {
+ const bool g_x = (player.local_pos.x >= shared::world::chunk::WIDTH);
+ const bool l_x = (player.local_pos.x < 0.0f);
+ const bool g_z = (player.local_pos.z >= shared::world::chunk::WIDTH);
+ const bool l_z = (player.local_pos.z < 0.0f);
+
+ player.chunk_pos.x += g_x - l_x;
+ player.local_pos.x += shared::world::chunk::WIDTH * (l_x - g_x);
+ player.chunk_pos.z += g_z - l_z;
+ player.local_pos.z += shared::world::chunk::WIDTH * (l_z - g_z);
+}
+
+constexpr float epsilon = 0.001f; // counteract arithmetic errors
+constexpr float epsilon2 = epsilon + 2 * epsilon * epsilon;
+
+bool intersect_aabbs(const aabb& a, const aabb& b) noexcept {
+ if (a.max.x < b.min.x || a.min.x > b.max.x) {
+ return false;
+ }
+ if (a.max.y < b.min.y || a.min.y > b.max.y) {
+ return false;
+ }
+ if (a.max.z < b.min.z || a.min.z > b.max.z) {
+ return false;
+ }
+ return true;
+}
+
+static glm::vec3 plane_to_normal(const int plane) {
+ glm::vec3 normal{0.0f, 0.0f, 0.0f};
+ normal[std::abs(plane) - 1] = std::signbit(plane) ? -1.0f : 1.0f;
+ return normal;
+}
+
+std::optional<ray_aabb_ret> intersect_ray_aabb(const line& line,
+ const aabb& aabb) noexcept {
+ float tmin = -std::numeric_limits<float>::max();
+ float tmax = std::numeric_limits<float>::max();
+
+ int p = 0;
+ for (int i = 0; i < 3; ++i) {
+ if (std::abs(line.dir[i]) < epsilon) {
+
+ // Ray is parallel to slab, no hit if origin not within slab.
+ if (line.origin[i] < aabb.min[i] || line.origin[i] > aabb.max[i]) {
+ return std::nullopt;
+ }
+
+ } else {
+ // Intersection t value of ray with near and far plane of slab.
+ const float ood = 1.0f / line.dir[i];
+ float t1 = (aabb.min[i] - line.origin[i]) * ood;
+ float t2 = (aabb.max[i] - line.origin[i]) * ood;
+
+ if (t1 > t2) {
+ std::swap(t1, t2);
+ }
+ auto old = tmin;
+ tmin = std::max(tmin, t1);
+ if (tmin != old) {
+ p = (i + 1);
+ }
+ tmax = std::min(tmax, t2);
+ if (tmin > tmax) {
+ return std::nullopt;
+ }
+ }
+ }
+
+ if (tmin <= 0.0f) {
+ return std::nullopt;
+ }
+
+ return ray_aabb_ret{.position = line.origin + line.dir * tmin,
+ .time = tmin,
+ .normal = plane_to_normal(p)};
+}
+
+std::optional<moving_aabb_ret>
+intersect_moving_aabbs(const moving_aabb& a, const moving_aabb& b) noexcept {
+
+ if (intersect_aabbs(a.aabb, b.aabb)) {
+ return std::nullopt;
+ }
+
+ const glm::vec3 velocity = b.velocity - a.velocity;
+ float tfirst = 0.0f;
+ float tlast = 10.0f;
+ int p = 0;
+
+ for (int i = 0; i < 3; ++i) {
+ if (velocity[i] < 0.0f) {
+ if (b.aabb.max[i] < a.aabb.min[i]) {
+ return std::nullopt;
+ }
+ if (a.aabb.max[i] < b.aabb.min[i]) {
+ const auto old = tfirst;
+ tfirst = std::max((a.aabb.max[i] - b.aabb.min[i]) / velocity[i],
+ tfirst);
+ if (tfirst != old) {
+ p = (i + 1);
+ }
+ }
+ if (b.aabb.max[i] > a.aabb.min[i]) {
+ tlast = std::min((a.aabb.min[i] - b.aabb.max[i]) / velocity[i],
+ tlast);
+ }
+ } else if (velocity[i] > 0.0f) {
+ if (b.aabb.min[i] > a.aabb.max[i]) {
+ return std::nullopt;
+ }
+ if (b.aabb.max[i] < a.aabb.min[i]) {
+ const auto old = tfirst;
+ tfirst = std::max((a.aabb.min[i] - b.aabb.max[i]) / velocity[i],
+ tfirst);
+ if (tfirst != old) {
+ p = -(i + 1);
+ }
+ }
+ if (a.aabb.max[i] > b.aabb.min[i]) {
+ tlast = std::min((a.aabb.max[i] - b.aabb.min[i]) / velocity[i],
+ tlast);
+ }
+ } else {
+ if (b.aabb.max[i] < a.aabb.min[i] ||
+ b.aabb.min[i] > a.aabb.max[i]) {
+ return std::nullopt;
+ }
+ }
+ if (tfirst > tlast) {
+ return std::nullopt;
+ }
+ }
+ /*
+ if (tfirst < 0.0f || tfirst > 1.0f) {
+ return std::nullopt;
+ }
+ */
+
+ return moving_aabb_ret{.time = tfirst, .normal = plane_to_normal(p)};
+}
+
+static std::optional<shared::world::block>
+get_ground(const aabb& player_aabb, const std::vector<blockinfo> blockinfos,
+ bool (*delimit)(const enum shared::world::block::type) =
+ shared::world::block::is_tangible) noexcept {
+
+ const moving_aabb player_moving_aabb{.aabb = player_aabb,
+ .velocity = {0.0f, -1.0f, 0.0f}};
+ for (const auto& block_aabb : blockinfos) {
+
+ if (!delimit(block_aabb.block)) {
+ continue;
+ }
+
+ const struct moving_aabb block_moving_aabb {
+ .aabb = block_aabb.aabb, .velocity = { 0.0f, 0.0f, 0.0f }
+ };
+
+ if (const auto intersect =
+ intersect_moving_aabbs(player_moving_aabb, block_moving_aabb);
+ intersect.has_value()) {
+
+ if (intersect->time >= 1.0f) {
+ continue;
+ }
+
+ if (intersect->time <= epsilon2) {
+ return block_aabb.block;
+ }
+ }
+ }
+ return std::nullopt;
+}
+
+// Only returns ground if we can collide with it.
+static std::optional<shared::world::block>
+get_collidable_ground(const aabb& player_aabb,
+ const std::vector<blockinfo> blockinfo) noexcept {
+
+ return get_ground(player_aabb, blockinfo,
+ shared::world::block::is_collidable);
+}
+
+// Recursively resolve collisions against blocks, up to n times.
+static void resolve_collisions(shared::player& player, aabb player_aabb,
+ const std::vector<blockinfo>& blockinfos,
+ const float deltatime,
+ const int n = 3) noexcept {
+
+ const moving_aabb player_moving_aabb{
+ .aabb = player_aabb, .velocity = player.velocity * deltatime};
+
+ std::optional<std::pair<moving_aabb_ret, shared::world::block>> collision;
+ for (const auto& block_aabb : blockinfos) {
+ if (!shared::world::block::is_collidable(block_aabb.block)) {
+ continue;
+ }
+
+ const struct moving_aabb block_moving_aabb {
+ .aabb = block_aabb.aabb, .velocity = { 0.0f, 0.0f, 0.0f }
+ };
+ const auto intersect =
+ intersect_moving_aabbs(player_moving_aabb, block_moving_aabb);
+
+ if (!intersect.has_value() || intersect->time > 1.0f) {
+ continue;
+ }
+
+ // Update collision if it doesn't exist or if this one is closer.
+ if (!collision.has_value() || intersect->time < collision->first.time) {
+
+ collision = std::make_pair(intersect.value(), block_aabb.block);
+ }
+ }
+
+ // No more collisions :)
+ if (!collision.has_value()) {
+ player.local_pos += player.velocity * deltatime;
+ return;
+ }
+
+ const glm::vec3 collision_pos =
+ collision->first.time * player.velocity * deltatime;
+ const glm::vec3 offset = collision->first.normal * epsilon;
+ const float backoff = glm::dot(player.velocity, collision->first.normal);
+
+#ifndef NDEBUG
+ // clang-format off
+ shared::print::debug("Collision with n = " + std::to_string(n) + "\n");
+ shared::print::message(" Unresolved player position: {" + std::to_string(player.local_pos.x) + ", " + std::to_string(player.local_pos.y) + ", " + std::to_string(player.local_pos.z) + "}\n", false);
+ shared::print::message(" Unresolved player velocity: {" + std::to_string(player.velocity.x) + ", " + std::to_string(player.velocity.y) + ", " + std::to_string(player.velocity.z) + "}\n", false);
+ shared::print::message(" Collision delta vector: {" + std::to_string(collision_pos.x) + ", " + std::to_string(collision_pos.y) + ", " + std::to_string(collision_pos.z) + "}\n", false);
+ shared::print::message(" Backoff: " + std::to_string(backoff) + "\n", false);
+ shared::print::message(" On ground before collision: " + std::to_string(get_collidable_ground(player_aabb, blockinfos).has_value()) + "\n", false);
+ shared::print::message(" Collision normal: {" + std::to_string(collision->first.normal.x) + ", " + std::to_string(collision->first.normal.y) + ", " + std::to_string(collision->first.normal.z) + "}\n", false);
+ // clang-format on
+#endif
+
+ // Quake engine's reflect velocity.
+ for (int i = 0; i < 3; ++i) {
+ player.velocity[i] -= collision->first.normal[i] * backoff;
+ if (std::abs(player.velocity[i]) <= epsilon) {
+ player.velocity[i] = 0.0f;
+ }
+ if (std::abs(collision_pos[i]) <= epsilon2) {
+
+#ifndef NDEBUG
+ shared::print::message(
+ " Ignored axis: " + std::to_string(i) + "\n", false);
+#endif
+
+ continue;
+ }
+ player.local_pos[i] += collision_pos[i] - offset[i];
+ player_aabb.min[i] += collision_pos[i] - offset[i];
+ player_aabb.max[i] += collision_pos[i] - offset[i];
+ }
+
+#ifndef NDEBUG
+ // clang-format off
+ shared::print::message(" Resolved player position: {" + std::to_string(player.local_pos.x) + ", " + std::to_string(player.local_pos.y) + ", " + std::to_string(player.local_pos.z) + "}\n", false);
+ shared::print::message(" Resolved player velocity: {" + std::to_string(player.velocity.x) + ", " + std::to_string(player.velocity.y) + ", " + std::to_string(player.velocity.z) + "}\n", false);
+ shared::print::message(" On ground after collision: " + std::to_string(get_collidable_ground(player_aabb, blockinfos).has_value()) + "\n", false);
+ // clang-format on
+#endif
+
+ if (n <= 0) {
+ return;
+ }
+ resolve_collisions(player, player_aabb, blockinfos,
+ deltatime - collision->first.time * deltatime, n - 1);
+}
+
+// Returns the highest friction value of a block that intersects an aabb.
+static std::optional<float>
+get_intersect_friction(const aabb& aabb,
+ const std::vector<blockinfo>& blockinfos) noexcept {
+ std::optional<float> greatest_friction;
+ for (const auto& block_aabb : blockinfos) {
+ if (!intersect_aabbs(aabb, block_aabb.aabb)) {
+ continue;
+ }
+ const float friction =
+ shared::world::block::get_friction(block_aabb.block);
+
+ if (!greatest_friction.has_value() ||
+ friction > greatest_friction.value()) {
+
+ greatest_friction = friction;
+ }
+ }
+
+ return greatest_friction;
+}
+
+// In air is slightly more complicated becase of edge cases involving water.
+static bool is_in_air(
+ const aabb& aabb, const std::vector<blockinfo>& blockinfos,
+ const std::optional<shared::world::block>& collidable_ground) noexcept {
+ if (!std::all_of(std::begin(blockinfos), std::end(blockinfos),
+ [&aabb](const auto& ba) {
+ if (!intersect_aabbs(aabb, ba.aabb)) {
+ return true;
+ }
+ return !shared::world::block::is_tangible(ba.block);
+ })) {
+ return false;
+ }
+ if (collidable_ground.has_value()) {
+ return false;
+ }
+ return true;
+}
+
+static bool is_in_liquid(const aabb& aabb,
+ const std::vector<blockinfo>& blockinfos) noexcept {
+ return std::any_of(std::begin(blockinfos), std::end(blockinfos),
+ [&aabb](const auto& ba) {
+ if (!intersect_aabbs(aabb, ba.aabb)) {
+ return false;
+ }
+ return shared::world::block::is_liquid(ba.block);
+ });
+}
+
+static bool
+can_jump(const std::optional<shared::world::block>& collidable_ground,
+ const bool in_liquid) noexcept {
+ if (collidable_ground.has_value()) {
+ return true;
+ }
+ if (in_liquid) {
+ return true;
+ }
+ return false;
+}
+
+// Move state is a cache of expensive operations that we use more than once.
+struct move_state {
+ std::optional<shared::world::block> ground;
+ std::optional<shared::world::block> collidable_ground;
+ bool is_in_air;
+ bool is_in_liquid;
+ bool can_jump;
+};
+static move_state
+make_move_state(const aabb& player_aabb,
+ const std::vector<blockinfo>& blockinfos) noexcept {
+
+ const auto get_ground_ret = get_ground(player_aabb, blockinfos);
+ const auto get_collidable_ground_ret =
+ get_collidable_ground(player_aabb, blockinfos);
+ const bool is_in_air_ret =
+ is_in_air(player_aabb, blockinfos, get_collidable_ground_ret);
+ const bool is_in_liquid_ret = is_in_liquid(player_aabb, blockinfos);
+ const bool can_jump_ret =
+ can_jump(get_collidable_ground_ret, is_in_liquid_ret);
+
+ return {.ground = get_ground_ret,
+ .collidable_ground = get_collidable_ground_ret,
+ .is_in_air = is_in_air_ret,
+ .is_in_liquid = is_in_liquid_ret,
+ .can_jump = can_jump_ret};
+}
+
+static float get_jump_magnitude(const shared::player& player, const aabb& aabb,
+ const std::vector<blockinfo>& blockinfos,
+ const struct move_state& move_state) noexcept {
+ if (!move_state.can_jump) {
+ return 0.0f;
+ }
+ if (move_state.is_in_liquid) {
+ const struct aabb jump_aabb = {
+ .min = glm::vec3{0.0f, aabb.min.y + aabb.max.y / 5.0f, 0.0f},
+ .max = aabb.max};
+ if (player.velocity.y > 0.0f &&
+ is_in_air(jump_aabb, blockinfos,
+ get_collidable_ground(jump_aabb, blockinfos))) {
+ return 1.0f;
+ }
+ return 0.5f;
+ }
+ if (player.velocity.y < 0.0f) {
+ return 0.0f;
+ }
+ return 8.0f;
+}
+
+void move(shared::player& player, const std::vector<blockinfo>& blockinfos,
+ const float deltatime) noexcept {
+
+ constexpr glm::vec3 up = glm::vec3(0.0f, 1.0f, 0.0f);
+ const glm::vec3 front = shared::math::angle_to_dir(player.viewangles);
+ const glm::vec3 right = glm::normalize(glm::cross(front, up));
+
+ constexpr aabb player_aabb = {.min = {-shared::player::HALFWIDTH + epsilon,
+ 0.0f + epsilon,
+ -shared::player::HALFWIDTH + epsilon},
+ .max = {shared::player::HALFWIDTH - epsilon,
+ shared::player::HEIGHT - epsilon,
+ shared::player::HALFWIDTH - epsilon}};
+
+ const auto move_state = make_move_state(player_aabb, blockinfos);
+
+ // Some of velocity we want to add or remove should be scaled by our
+ // tickrate (eg, walking), while others such as jumping should not.
+
+ const glm::vec3 scaled_acceleration = [&]() -> glm::vec3 {
+ glm::vec3 acceleration = {0.0f, 0.0f, 0.0f};
+ if (player.commands & shared::player::mask::forward) {
+ acceleration += front;
+ }
+ if (player.commands & shared::player::mask::left) {
+ acceleration -= right;
+ }
+ if (player.commands & shared::player::mask::backward) {
+ acceleration -= front;
+ }
+ if (player.commands & shared::player::mask::right) {
+ acceleration += right;
+ }
+ acceleration.y = 0.0f;
+ if (acceleration != glm::vec3{}) {
+ acceleration = glm::normalize(acceleration);
+ }
+ acceleration *= 1.75f;
+ if (player.commands & shared::player::mask::sprint) {
+ acceleration *= 1.25f;
+ }
+
+ // Increase movement when on the ground - heavily reduced with friction.
+ if (!move_state.is_in_air) {
+ acceleration *= 30.0f;
+ }
+
+ // Gravity.
+ if (!move_state.collidable_ground.has_value()) {
+ acceleration -= 25.0f * up;
+ }
+
+ return acceleration;
+ }();
+
+ const glm::vec3 constant_acceleration = [&]() -> glm::vec3 {
+ glm::vec3 acceleration = {0.0f, 0.0f, 0.0f};
+ // Jumping - we have to adjust our magnitude based on our environment.
+ // Technically swimming is just lots of small jumps.
+ if (player.commands & shared::player::mask::jump) {
+ acceleration += get_jump_magnitude(player, player_aabb, blockinfos,
+ move_state) *
+ up;
+ }
+ return acceleration;
+ }();
+
+ // Our deceleration is the max friction of what we're in and what we're on.
+ const glm::vec3 scaled_deceleration = [&]() -> glm::vec3 {
+ const auto drag = get_intersect_friction(player_aabb, blockinfos);
+
+ float max_friction = 0.0f;
+ if (move_state.collidable_ground.has_value()) {
+ const float friction = shared::world::block::get_friction(
+ move_state.collidable_ground.value());
+ if (drag.has_value()) {
+ max_friction = std::max(friction, drag.value());
+ }
+ } else if (drag.has_value()) {
+ max_friction = drag.value();
+ }
+
+ return player.velocity * max_friction;
+ }();
+
+ player.velocity += (scaled_acceleration - scaled_deceleration) * deltatime;
+ player.velocity += constant_acceleration;
+
+ resolve_collisions(player, player_aabb, blockinfos, deltatime);
+
+ shift_chunk(player);
+}
+
+} // namespace movement
+} // namespace shared
diff --git a/src/shared/movement.hh b/src/shared/movement.hh
new file mode 100644
index 0000000..375c030
--- /dev/null
+++ b/src/shared/movement.hh
@@ -0,0 +1,67 @@
+#ifndef SHARED_MOVEMENT_HH_
+#define SHARED_MOVEMENT_HH_
+
+#include "shared/math.hh"
+#include "shared/player.hh"
+#include "shared/shared.hh"
+#include "shared/world.hh"
+
+#include <algorithm>
+#include <array>
+
+#include <glm/glm.hpp>
+#include <glm/gtx/norm.hpp>
+
+namespace shared {
+namespace movement {
+
+struct aabb {
+ glm::vec3 min;
+ glm::vec3 max;
+};
+bool intersect_aabbs(const aabb& a, const aabb& b) noexcept;
+
+struct line {
+ glm::vec3 origin;
+ glm::vec3 dir;
+};
+struct ray_aabb_ret {
+ glm::vec3 position;
+ float time;
+ glm::vec3 normal;
+};
+std::optional<ray_aabb_ret> intersect_ray_aabb(const line& line,
+ const aabb& aabb) noexcept;
+struct moving_aabb {
+ struct aabb aabb;
+ glm::vec3 velocity;
+};
+struct moving_aabb_ret {
+ float time;
+ glm::vec3 normal;
+};
+std::optional<moving_aabb_ret>
+intersect_moving_aabbs(const moving_aabb& a, const moving_aabb& b) noexcept;
+
+// A block with a bit more info.
+struct blockinfo {
+ shared::world::block block;
+ struct aabb aabb;
+ shared::math::coords chunk_pos;
+ glm::ivec3 pos;
+};
+// /WE/ should use this function to generate our blockdatas.
+constexpr int move_width =
+ static_cast<int>(1.0f + 2 * shared::player::HALFWIDTH + 1.0f);
+constexpr int move_height = static_cast<int>(1.0f + shared::player::HEIGHT);
+
+// Walking a player is fairly complicated, and requires a std::vector of
+// blockdata that represents all the blocks near a player.
+// TODO provide an additional deltatime arugment to enable prediction.
+void move(shared::player& player, const std::vector<blockinfo>& blockinfos,
+ const float deltatime) noexcept;
+
+} // namespace movement
+} // namespace shared
+
+#endif
diff --git a/src/shared/net/connection.cc b/src/shared/net/connection.cc
new file mode 100644
index 0000000..79a83f5
--- /dev/null
+++ b/src/shared/net/connection.cc
@@ -0,0 +1 @@
+#include "shared/net/connection.hh"
diff --git a/src/shared/net/connection.hh b/src/shared/net/connection.hh
new file mode 100644
index 0000000..79146af
--- /dev/null
+++ b/src/shared/net/connection.hh
@@ -0,0 +1,212 @@
+#ifndef SHARED_NET_CONNECTION_HH_
+#define SHARED_NET_CONNECTION_HH_
+
+#include <algorithm>
+#include <optional>
+#include <string>
+
+#include "shared/net/net.hh"
+#include "shared/net/proto.hh"
+
+namespace shared {
+namespace net {
+
+class connection {
+private:
+ struct sockets {
+ int rsock;
+ int usock; // connected in constructor, no need to use sendto or revfrom
+ std::string address;
+ std::string port;
+
+ sockets(const int r, const int u, const std::string& a,
+ const std::string& p)
+ : rsock(r), usock(u), address(a), port(p) {}
+ };
+ std::optional<sockets> socks;
+ std::optional<std::string> bad_reason;
+
+private:
+ struct packet_header {
+ std::uint32_t size;
+ };
+
+ // Data has a non-serialised header, and variable length serialised
+ // protobuf content.
+ static std::string packet_to_data(const proto::packet& packet) {
+
+ std::string data;
+ packet.SerializeToString(&data);
+ shared::compress_string(data);
+
+ packet_header header{.size = htonl(static_cast<std::uint32_t>(
+ std::size(data) + sizeof(packet_header)))};
+
+ return std::string{reinterpret_cast<char*>(&header),
+ reinterpret_cast<char*>(&header) + sizeof(header)} +
+ std::move(data);
+ }
+
+ void send_sock_packet(const int sock, const proto::packet& packet) {
+ if (!this->good()) {
+ return;
+ }
+
+ const std::string data = packet_to_data(packet);
+
+ if (send(sock, std::data(data), std::size(data), 0) == -1) {
+ this->bad_reason = shared::net::get_errno_error();
+ }
+ }
+
+public:
+ connection(const int rsock) {
+ using namespace shared::net;
+
+ const std::string peer_address = get_socket_peer_address(rsock);
+ const std::string peer_port = get_socket_peer_port(rsock);
+
+ // Open up a connected usock based on the state of the connected rsock.
+ const int usock = [&peer_address, &peer_port, &rsock]() -> int {
+ constexpr addrinfo hints = {.ai_flags = AI_PASSIVE,
+ .ai_family = AF_INET,
+ .ai_socktype = SOCK_DGRAM};
+ const std::string host_address = get_socket_host_address(rsock);
+ const std::string host_port = get_socket_host_port(rsock);
+ const auto host_info =
+ get_addr_info(host_address, host_port, &hints);
+ const int usock = make_socket(host_info.get());
+ bind_socket(usock, host_info.get());
+
+ const auto peer_info =
+ get_addr_info(peer_address, peer_port, &hints);
+ connect_socket(usock, peer_info.get());
+
+ return usock;
+ }();
+
+ nonblock_socket(usock);
+ nonblock_socket(rsock);
+
+ this->socks.emplace(rsock, usock, peer_address, peer_port);
+ }
+
+ // We do not want to copy this object!
+ // We use std::nullopt to determine if this object has been moved and if we
+ // should close its sockets.
+ connection(const connection&) = delete;
+ connection(connection&& other) noexcept {
+ std::swap(this->socks, other.socks);
+ std::swap(this->bad_reason, other.bad_reason);
+ other.socks.reset();
+ }
+ connection& operator=(connection&& other) noexcept {
+ std::swap(this->socks, other.socks);
+ std::swap(this->bad_reason, other.bad_reason);
+ other.socks.reset();
+ return *this;
+ }
+ ~connection() noexcept {
+ if (this->socks.has_value()) {
+ shared::net::close_socket(socks->rsock);
+ shared::net::close_socket(socks->usock);
+ }
+ }
+
+ // Getters.
+ bool good() const noexcept { return !bad_reason.has_value(); }
+ std::string get_bad_reason() const noexcept {
+ return this->bad_reason.value();
+ }
+ std::string get_address() const noexcept { return this->socks->address; }
+
+public:
+ // Send does nothing if good() returns false!
+ // Returns whether or not we were able to send our packet.
+ void rsend_packet(const proto::packet& packet) noexcept {
+ return send_sock_packet(this->socks->rsock, packet);
+ }
+ void usend_packet(const proto::packet& packet) noexcept {
+ return send_sock_packet(this->socks->usock, packet);
+ }
+ std::optional<proto::packet> rrecv_packet() noexcept {
+ const int sock = this->socks->rsock;
+
+ // Get the size of the backlog, early out of there's nothing there yet.
+ const auto backlog_size = shared::net::get_backlog_size(sock);
+ if (backlog_size < sizeof(packet_header)) {
+ return std::nullopt;
+ }
+
+ // Read for the packet headers and get the claimed size. Early out if
+ // our stream isn't big enough for that yet.
+ packet_header header = {};
+ recv(sock, &header, sizeof(header), MSG_PEEK);
+ const std::uint32_t read_packet_size = ntohl(header.size);
+ if (backlog_size < read_packet_size) {
+ return std::nullopt;
+ }
+
+ // Read the actual packet now, based on our claimed size.
+ std::string data;
+ data.reserve(read_packet_size);
+ if (read(sock, std::data(data), read_packet_size) == -1) {
+ this->bad_reason = shared::net::get_errno_error();
+ return std::nullopt;
+ }
+
+ data = std::string{
+ reinterpret_cast<char*>(std::data(data)) + sizeof(packet_header),
+ reinterpret_cast<char*>(std::data(data)) + read_packet_size};
+ shared::decompress_string(data);
+
+ // Parse the packet, ignoring the header.
+ proto::packet packet;
+ if (!packet.ParseFromString(data)) {
+ return std::nullopt;
+ }
+
+ return packet;
+ }
+ std::optional<proto::packet> urecv_packet() noexcept {
+ const int sock = this->socks->usock;
+
+ restart:
+ const auto packet_size = shared::net::get_backlog_size(sock);
+
+ if (packet_size == 0) {
+ return std::nullopt;
+ }
+
+ std::string data;
+ data.reserve(packet_size);
+ if (recv(sock, std::data(data), packet_size, 0) == -1) {
+ this->bad_reason = shared::net::get_errno_error();
+ return std::nullopt;
+ }
+
+ data = std::string{
+ reinterpret_cast<char*>(std::data(data)) + sizeof(packet_header),
+ reinterpret_cast<char*>(std::data(data)) + packet_size};
+ shared::decompress_string(data);
+
+ proto::packet packet;
+ if (!packet.ParseFromString(data)) {
+ goto restart;
+ }
+
+ return packet;
+ }
+ // Gets packets from r/u streams, doesn't care which.
+ std::optional<proto::packet> recv_packet() noexcept {
+ if (const auto ret = urecv_packet(); ret.has_value()) {
+ return ret;
+ }
+ return rrecv_packet();
+ }
+};
+
+} // namespace net
+} // namespace shared
+
+#endif
diff --git a/src/shared/net/lib/protobuf/net.pb.cc b/src/shared/net/lib/protobuf/net.pb.cc
new file mode 100644
index 0000000..a938799
--- /dev/null
+++ b/src/shared/net/lib/protobuf/net.pb.cc
@@ -0,0 +1,5548 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: net.proto
+
+#include "net.pb.h"
+
+#include <algorithm>
+
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/extension_set.h>
+#include <google/protobuf/wire_format_lite.h>
+#include <google/protobuf/descriptor.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/reflection_ops.h>
+#include <google/protobuf/wire_format.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+
+PROTOBUF_PRAGMA_INIT_SEG
+namespace proto {
+constexpr angles::angles(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : pitch_(0)
+ , yaw_(0){}
+struct anglesDefaultTypeInternal {
+ constexpr anglesDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~anglesDefaultTypeInternal() {}
+ union {
+ angles _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT anglesDefaultTypeInternal _angles_default_instance_;
+constexpr coords::coords(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : x_(0)
+ , z_(0){}
+struct coordsDefaultTypeInternal {
+ constexpr coordsDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~coordsDefaultTypeInternal() {}
+ union {
+ coords _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT coordsDefaultTypeInternal _coords_default_instance_;
+constexpr vec3::vec3(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : x_(0)
+ , y_(0)
+ , z_(0){}
+struct vec3DefaultTypeInternal {
+ constexpr vec3DefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~vec3DefaultTypeInternal() {}
+ union {
+ vec3 _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT vec3DefaultTypeInternal _vec3_default_instance_;
+constexpr ivec3::ivec3(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : x_(0)
+ , y_(0)
+ , z_(0){}
+struct ivec3DefaultTypeInternal {
+ constexpr ivec3DefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~ivec3DefaultTypeInternal() {}
+ union {
+ ivec3 _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT ivec3DefaultTypeInternal _ivec3_default_instance_;
+constexpr player::player(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : chunk_pos_(nullptr)
+ , local_pos_(nullptr)
+ , viewangles_(nullptr)
+ , velocity_(nullptr)
+ , index_(0u)
+ , commands_(0u){}
+struct playerDefaultTypeInternal {
+ constexpr playerDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~playerDefaultTypeInternal() {}
+ union {
+ player _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT playerDefaultTypeInternal _player_default_instance_;
+constexpr auth::auth(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : username_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , password_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct authDefaultTypeInternal {
+ constexpr authDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~authDefaultTypeInternal() {}
+ union {
+ auth _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT authDefaultTypeInternal _auth_default_instance_;
+constexpr init::init(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : localplayer_(nullptr)
+ , seed_(uint64_t{0u})
+ , draw_distance_(0){}
+struct initDefaultTypeInternal {
+ constexpr initDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~initDefaultTypeInternal() {}
+ union {
+ init _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT initDefaultTypeInternal _init_default_instance_;
+constexpr move::move(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : viewangles_(nullptr)
+ , commands_(0u){}
+struct moveDefaultTypeInternal {
+ constexpr moveDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~moveDefaultTypeInternal() {}
+ union {
+ move _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT moveDefaultTypeInternal _move_default_instance_;
+constexpr remove_player::remove_player(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : index_(0u){}
+struct remove_playerDefaultTypeInternal {
+ constexpr remove_playerDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~remove_playerDefaultTypeInternal() {}
+ union {
+ remove_player _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT remove_playerDefaultTypeInternal _remove_player_default_instance_;
+constexpr say::say(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : text_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string){}
+struct sayDefaultTypeInternal {
+ constexpr sayDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~sayDefaultTypeInternal() {}
+ union {
+ say _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT sayDefaultTypeInternal _say_default_instance_;
+constexpr hear_player::hear_player(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : text_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , index_(0u){}
+struct hear_playerDefaultTypeInternal {
+ constexpr hear_playerDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~hear_playerDefaultTypeInternal() {}
+ union {
+ hear_player _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT hear_playerDefaultTypeInternal _hear_player_default_instance_;
+constexpr request_chunk::request_chunk(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : chunk_pos_(nullptr){}
+struct request_chunkDefaultTypeInternal {
+ constexpr request_chunkDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~request_chunkDefaultTypeInternal() {}
+ union {
+ request_chunk _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT request_chunkDefaultTypeInternal _request_chunk_default_instance_;
+constexpr remove_chunk::remove_chunk(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : chunk_pos_(nullptr){}
+struct remove_chunkDefaultTypeInternal {
+ constexpr remove_chunkDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~remove_chunkDefaultTypeInternal() {}
+ union {
+ remove_chunk _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT remove_chunkDefaultTypeInternal _remove_chunk_default_instance_;
+constexpr chunk::chunk(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : blocks_()
+ , _blocks_cached_byte_size_(0)
+ , chunk_pos_(nullptr){}
+struct chunkDefaultTypeInternal {
+ constexpr chunkDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~chunkDefaultTypeInternal() {}
+ union {
+ chunk _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT chunkDefaultTypeInternal _chunk_default_instance_;
+constexpr add_block::add_block(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : chunk_pos_(nullptr)
+ , block_pos_(nullptr)
+ , block_(0u){}
+struct add_blockDefaultTypeInternal {
+ constexpr add_blockDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~add_blockDefaultTypeInternal() {}
+ union {
+ add_block _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT add_blockDefaultTypeInternal _add_block_default_instance_;
+constexpr remove_block::remove_block(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : chunk_pos_(nullptr)
+ , block_pos_(nullptr){}
+struct remove_blockDefaultTypeInternal {
+ constexpr remove_blockDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~remove_blockDefaultTypeInternal() {}
+ union {
+ remove_block _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT remove_blockDefaultTypeInternal _remove_block_default_instance_;
+constexpr server_message::server_message(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : message_(&::PROTOBUF_NAMESPACE_ID::internal::fixed_address_empty_string)
+ , fatal_(false){}
+struct server_messageDefaultTypeInternal {
+ constexpr server_messageDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~server_messageDefaultTypeInternal() {}
+ union {
+ server_message _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT server_messageDefaultTypeInternal _server_message_default_instance_;
+constexpr packet::packet(
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized)
+ : _oneof_case_{}{}
+struct packetDefaultTypeInternal {
+ constexpr packetDefaultTypeInternal()
+ : _instance(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized{}) {}
+ ~packetDefaultTypeInternal() {}
+ union {
+ packet _instance;
+ };
+};
+PROTOBUF_ATTRIBUTE_NO_DESTROY PROTOBUF_CONSTINIT packetDefaultTypeInternal _packet_default_instance_;
+} // namespace proto
+static ::PROTOBUF_NAMESPACE_ID::Metadata file_level_metadata_net_2eproto[18];
+static constexpr ::PROTOBUF_NAMESPACE_ID::EnumDescriptor const** file_level_enum_descriptors_net_2eproto = nullptr;
+static constexpr ::PROTOBUF_NAMESPACE_ID::ServiceDescriptor const** file_level_service_descriptors_net_2eproto = nullptr;
+
+const uint32_t TableStruct_net_2eproto::offsets[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::angles, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::angles, pitch_),
+ PROTOBUF_FIELD_OFFSET(::proto::angles, yaw_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::coords, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::coords, x_),
+ PROTOBUF_FIELD_OFFSET(::proto::coords, z_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::vec3, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::vec3, x_),
+ PROTOBUF_FIELD_OFFSET(::proto::vec3, y_),
+ PROTOBUF_FIELD_OFFSET(::proto::vec3, z_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::ivec3, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::ivec3, x_),
+ PROTOBUF_FIELD_OFFSET(::proto::ivec3, y_),
+ PROTOBUF_FIELD_OFFSET(::proto::ivec3, z_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::player, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::player, index_),
+ PROTOBUF_FIELD_OFFSET(::proto::player, commands_),
+ PROTOBUF_FIELD_OFFSET(::proto::player, chunk_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::player, local_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::player, viewangles_),
+ PROTOBUF_FIELD_OFFSET(::proto::player, velocity_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::auth, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::auth, username_),
+ PROTOBUF_FIELD_OFFSET(::proto::auth, password_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::init, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::init, seed_),
+ PROTOBUF_FIELD_OFFSET(::proto::init, draw_distance_),
+ PROTOBUF_FIELD_OFFSET(::proto::init, localplayer_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::move, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::move, commands_),
+ PROTOBUF_FIELD_OFFSET(::proto::move, viewangles_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_player, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_player, index_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::say, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::say, text_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::hear_player, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::hear_player, index_),
+ PROTOBUF_FIELD_OFFSET(::proto::hear_player, text_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::request_chunk, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::request_chunk, chunk_pos_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_chunk, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_chunk, chunk_pos_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::chunk, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::chunk, chunk_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::chunk, blocks_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::add_block, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::add_block, chunk_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::add_block, block_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::add_block, block_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_block, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::remove_block, chunk_pos_),
+ PROTOBUF_FIELD_OFFSET(::proto::remove_block, block_pos_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::server_message, _internal_metadata_),
+ ~0u, // no _extensions_
+ ~0u, // no _oneof_case_
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ PROTOBUF_FIELD_OFFSET(::proto::server_message, message_),
+ PROTOBUF_FIELD_OFFSET(::proto::server_message, fatal_),
+ ~0u, // no _has_bits_
+ PROTOBUF_FIELD_OFFSET(::proto::packet, _internal_metadata_),
+ ~0u, // no _extensions_
+ PROTOBUF_FIELD_OFFSET(::proto::packet, _oneof_case_[0]),
+ ~0u, // no _weak_field_map_
+ ~0u, // no _inlined_string_donated_
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ ::PROTOBUF_NAMESPACE_ID::internal::kInvalidFieldOffsetTag,
+ PROTOBUF_FIELD_OFFSET(::proto::packet, contents_),
+};
+static const ::PROTOBUF_NAMESPACE_ID::internal::MigrationSchema schemas[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) = {
+ { 0, -1, -1, sizeof(::proto::angles)},
+ { 8, -1, -1, sizeof(::proto::coords)},
+ { 16, -1, -1, sizeof(::proto::vec3)},
+ { 25, -1, -1, sizeof(::proto::ivec3)},
+ { 34, -1, -1, sizeof(::proto::player)},
+ { 46, -1, -1, sizeof(::proto::auth)},
+ { 54, -1, -1, sizeof(::proto::init)},
+ { 63, -1, -1, sizeof(::proto::move)},
+ { 71, -1, -1, sizeof(::proto::remove_player)},
+ { 78, -1, -1, sizeof(::proto::say)},
+ { 85, -1, -1, sizeof(::proto::hear_player)},
+ { 93, -1, -1, sizeof(::proto::request_chunk)},
+ { 100, -1, -1, sizeof(::proto::remove_chunk)},
+ { 107, -1, -1, sizeof(::proto::chunk)},
+ { 115, -1, -1, sizeof(::proto::add_block)},
+ { 124, -1, -1, sizeof(::proto::remove_block)},
+ { 132, -1, -1, sizeof(::proto::server_message)},
+ { 140, -1, -1, sizeof(::proto::packet)},
+};
+
+static ::PROTOBUF_NAMESPACE_ID::Message const * const file_default_instances[] = {
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_angles_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_coords_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_vec3_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_ivec3_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_player_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_auth_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_init_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_move_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_remove_player_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_say_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_hear_player_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_request_chunk_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_remove_chunk_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_chunk_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_add_block_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_remove_block_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_server_message_default_instance_),
+ reinterpret_cast<const ::PROTOBUF_NAMESPACE_ID::Message*>(&::proto::_packet_default_instance_),
+};
+
+const char descriptor_table_protodef_net_2eproto[] PROTOBUF_SECTION_VARIABLE(protodesc_cold) =
+ "\n\tnet.proto\022\005proto\"$\n\006angles\022\r\n\005pitch\030\001 "
+ "\001(\002\022\013\n\003yaw\030\002 \001(\002\"\036\n\006coords\022\t\n\001x\030\001 \001(\005\022\t\n"
+ "\001z\030\002 \001(\005\"\'\n\004vec3\022\t\n\001x\030\001 \001(\002\022\t\n\001y\030\002 \001(\002\022\t"
+ "\n\001z\030\003 \001(\002\"(\n\005ivec3\022\t\n\001x\030\001 \001(\005\022\t\n\001y\030\002 \001(\005"
+ "\022\t\n\001z\030\003 \001(\005\"\255\001\n\006player\022\r\n\005index\030\001 \001(\r\022\020\n"
+ "\010commands\030\002 \001(\r\022 \n\tchunk_pos\030\003 \001(\0132\r.pro"
+ "to.coords\022\036\n\tlocal_pos\030\004 \001(\0132\013.proto.vec"
+ "3\022!\n\nviewangles\030\005 \001(\0132\r.proto.angles\022\035\n\010"
+ "velocity\030\006 \001(\0132\013.proto.vec3\"*\n\004auth\022\020\n\010u"
+ "sername\030\001 \001(\t\022\020\n\010password\030\002 \001(\t\"O\n\004init\022"
+ "\014\n\004seed\030\001 \001(\004\022\025\n\rdraw_distance\030\002 \001(\005\022\"\n\013"
+ "localplayer\030\003 \001(\0132\r.proto.player\";\n\004move"
+ "\022\020\n\010commands\030\001 \001(\r\022!\n\nviewangles\030\002 \001(\0132\r"
+ ".proto.angles\"\036\n\rremove_player\022\r\n\005index\030"
+ "\001 \001(\r\"\023\n\003say\022\014\n\004text\030\001 \001(\t\"*\n\013hear_playe"
+ "r\022\r\n\005index\030\001 \001(\r\022\014\n\004text\030\002 \001(\t\"1\n\rreques"
+ "t_chunk\022 \n\tchunk_pos\030\001 \001(\0132\r.proto.coord"
+ "s\"0\n\014remove_chunk\022 \n\tchunk_pos\030\001 \001(\0132\r.p"
+ "roto.coords\"=\n\005chunk\022 \n\tchunk_pos\030\001 \001(\0132"
+ "\r.proto.coords\022\022\n\006blocks\030\002 \003(\rB\002\020\001\"]\n\tad"
+ "d_block\022 \n\tchunk_pos\030\001 \001(\0132\r.proto.coord"
+ "s\022\037\n\tblock_pos\030\002 \001(\0132\014.proto.ivec3\022\r\n\005bl"
+ "ock\030\003 \001(\r\"Q\n\014remove_block\022 \n\tchunk_pos\030\001"
+ " \001(\0132\r.proto.coords\022\037\n\tblock_pos\030\002 \001(\0132\014"
+ ".proto.ivec3\"0\n\016server_message\022\017\n\007messag"
+ "e\030\001 \001(\t\022\r\n\005fatal\030\002 \001(\010\"\334\004\n\006packet\022\"\n\013aut"
+ "h_packet\030\001 \001(\0132\013.proto.authH\000\022\"\n\013init_pa"
+ "cket\030\002 \001(\0132\013.proto.initH\000\022\"\n\013move_packet"
+ "\030\003 \001(\0132\013.proto.moveH\000\022&\n\rplayer_packet\030\004"
+ " \001(\0132\r.proto.playerH\000\0224\n\024remove_player_p"
+ "acket\030\005 \001(\0132\024.proto.remove_playerH\000\022 \n\ns"
+ "ay_packet\030\006 \001(\0132\n.proto.sayH\000\0220\n\022hear_pl"
+ "ayer_packet\030\007 \001(\0132\022.proto.hear_playerH\000\022"
+ "4\n\024request_chunk_packet\030\010 \001(\0132\024.proto.re"
+ "quest_chunkH\000\022$\n\014chunk_packet\030\t \001(\0132\014.pr"
+ "oto.chunkH\000\0222\n\023remove_chunk_packet\030\n \001(\013"
+ "2\023.proto.remove_chunkH\000\022,\n\020add_block_pac"
+ "ket\030\013 \001(\0132\020.proto.add_blockH\000\0222\n\023remove_"
+ "block_packet\030\014 \001(\0132\023.proto.remove_blockH"
+ "\000\0226\n\025server_message_packet\030\r \001(\0132\025.proto"
+ ".server_messageH\000B\n\n\010contentsb\006proto3"
+ ;
+static ::PROTOBUF_NAMESPACE_ID::internal::once_flag descriptor_table_net_2eproto_once;
+const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_net_2eproto = {
+ false, false, 1637, descriptor_table_protodef_net_2eproto, "net.proto",
+ &descriptor_table_net_2eproto_once, nullptr, 0, 18,
+ schemas, file_default_instances, TableStruct_net_2eproto::offsets,
+ file_level_metadata_net_2eproto, file_level_enum_descriptors_net_2eproto, file_level_service_descriptors_net_2eproto,
+};
+PROTOBUF_ATTRIBUTE_WEAK const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable* descriptor_table_net_2eproto_getter() {
+ return &descriptor_table_net_2eproto;
+}
+
+// Force running AddDescriptors() at dynamic initialization time.
+PROTOBUF_ATTRIBUTE_INIT_PRIORITY static ::PROTOBUF_NAMESPACE_ID::internal::AddDescriptorsRunner dynamic_init_dummy_net_2eproto(&descriptor_table_net_2eproto);
+namespace proto {
+
+// ===================================================================
+
+class angles::_Internal {
+ public:
+};
+
+angles::angles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.angles)
+}
+angles::angles(const angles& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::memcpy(&pitch_, &from.pitch_,
+ static_cast<size_t>(reinterpret_cast<char*>(&yaw_) -
+ reinterpret_cast<char*>(&pitch_)) + sizeof(yaw_));
+ // @@protoc_insertion_point(copy_constructor:proto.angles)
+}
+
+inline void angles::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&pitch_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&yaw_) -
+ reinterpret_cast<char*>(&pitch_)) + sizeof(yaw_));
+}
+
+angles::~angles() {
+ // @@protoc_insertion_point(destructor:proto.angles)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void angles::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void angles::ArenaDtor(void* object) {
+ angles* _this = reinterpret_cast< angles* >(object);
+ (void)_this;
+}
+void angles::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void angles::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void angles::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.angles)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ::memset(&pitch_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&yaw_) -
+ reinterpret_cast<char*>(&pitch_)) + sizeof(yaw_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* angles::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // float pitch = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
+ pitch_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // float yaw = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ yaw_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* angles::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.angles)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // float pitch = 1;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_pitch = this->_internal_pitch();
+ uint32_t raw_pitch;
+ memcpy(&raw_pitch, &tmp_pitch, sizeof(tmp_pitch));
+ if (raw_pitch != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_pitch(), target);
+ }
+
+ // float yaw = 2;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_yaw = this->_internal_yaw();
+ uint32_t raw_yaw;
+ memcpy(&raw_yaw, &tmp_yaw, sizeof(tmp_yaw));
+ if (raw_yaw != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_yaw(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.angles)
+ return target;
+}
+
+size_t angles::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.angles)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // float pitch = 1;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_pitch = this->_internal_pitch();
+ uint32_t raw_pitch;
+ memcpy(&raw_pitch, &tmp_pitch, sizeof(tmp_pitch));
+ if (raw_pitch != 0) {
+ total_size += 1 + 4;
+ }
+
+ // float yaw = 2;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_yaw = this->_internal_yaw();
+ uint32_t raw_yaw;
+ memcpy(&raw_yaw, &tmp_yaw, sizeof(tmp_yaw));
+ if (raw_yaw != 0) {
+ total_size += 1 + 4;
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData angles::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ angles::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*angles::GetClassData() const { return &_class_data_; }
+
+void angles::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<angles *>(to)->MergeFrom(
+ static_cast<const angles &>(from));
+}
+
+
+void angles::MergeFrom(const angles& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.angles)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_pitch = from._internal_pitch();
+ uint32_t raw_pitch;
+ memcpy(&raw_pitch, &tmp_pitch, sizeof(tmp_pitch));
+ if (raw_pitch != 0) {
+ _internal_set_pitch(from._internal_pitch());
+ }
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_yaw = from._internal_yaw();
+ uint32_t raw_yaw;
+ memcpy(&raw_yaw, &tmp_yaw, sizeof(tmp_yaw));
+ if (raw_yaw != 0) {
+ _internal_set_yaw(from._internal_yaw());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void angles::CopyFrom(const angles& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.angles)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool angles::IsInitialized() const {
+ return true;
+}
+
+void angles::InternalSwap(angles* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(angles, yaw_)
+ + sizeof(angles::yaw_)
+ - PROTOBUF_FIELD_OFFSET(angles, pitch_)>(
+ reinterpret_cast<char*>(&pitch_),
+ reinterpret_cast<char*>(&other->pitch_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata angles::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[0]);
+}
+
+// ===================================================================
+
+class coords::_Internal {
+ public:
+};
+
+coords::coords(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.coords)
+}
+coords::coords(const coords& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::memcpy(&x_, &from.x_,
+ static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ // @@protoc_insertion_point(copy_constructor:proto.coords)
+}
+
+inline void coords::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+}
+
+coords::~coords() {
+ // @@protoc_insertion_point(destructor:proto.coords)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void coords::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void coords::ArenaDtor(void* object) {
+ coords* _this = reinterpret_cast< coords* >(object);
+ (void)_this;
+}
+void coords::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void coords::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void coords::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.coords)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ::memset(&x_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* coords::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // int32 x = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // int32 z = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+ z_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* coords::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.coords)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // int32 x = 1;
+ if (this->_internal_x() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target);
+ }
+
+ // int32 z = 2;
+ if (this->_internal_z() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_z(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.coords)
+ return target;
+}
+
+size_t coords::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.coords)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // int32 x = 1;
+ if (this->_internal_x() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_x());
+ }
+
+ // int32 z = 2;
+ if (this->_internal_z() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_z());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData coords::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ coords::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*coords::GetClassData() const { return &_class_data_; }
+
+void coords::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<coords *>(to)->MergeFrom(
+ static_cast<const coords &>(from));
+}
+
+
+void coords::MergeFrom(const coords& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.coords)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_x() != 0) {
+ _internal_set_x(from._internal_x());
+ }
+ if (from._internal_z() != 0) {
+ _internal_set_z(from._internal_z());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void coords::CopyFrom(const coords& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.coords)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool coords::IsInitialized() const {
+ return true;
+}
+
+void coords::InternalSwap(coords* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(coords, z_)
+ + sizeof(coords::z_)
+ - PROTOBUF_FIELD_OFFSET(coords, x_)>(
+ reinterpret_cast<char*>(&x_),
+ reinterpret_cast<char*>(&other->x_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata coords::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[1]);
+}
+
+// ===================================================================
+
+class vec3::_Internal {
+ public:
+};
+
+vec3::vec3(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.vec3)
+}
+vec3::vec3(const vec3& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::memcpy(&x_, &from.x_,
+ static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ // @@protoc_insertion_point(copy_constructor:proto.vec3)
+}
+
+inline void vec3::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+}
+
+vec3::~vec3() {
+ // @@protoc_insertion_point(destructor:proto.vec3)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void vec3::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void vec3::ArenaDtor(void* object) {
+ vec3* _this = reinterpret_cast< vec3* >(object);
+ (void)_this;
+}
+void vec3::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void vec3::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void vec3::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.vec3)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ::memset(&x_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* vec3::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // float x = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 13)) {
+ x_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // float y = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 21)) {
+ y_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ // float z = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 29)) {
+ z_ = ::PROTOBUF_NAMESPACE_ID::internal::UnalignedLoad<float>(ptr);
+ ptr += sizeof(float);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* vec3::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.vec3)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // float x = 1;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_x = this->_internal_x();
+ uint32_t raw_x;
+ memcpy(&raw_x, &tmp_x, sizeof(tmp_x));
+ if (raw_x != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(1, this->_internal_x(), target);
+ }
+
+ // float y = 2;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_y = this->_internal_y();
+ uint32_t raw_y;
+ memcpy(&raw_y, &tmp_y, sizeof(tmp_y));
+ if (raw_y != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(2, this->_internal_y(), target);
+ }
+
+ // float z = 3;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_z = this->_internal_z();
+ uint32_t raw_z;
+ memcpy(&raw_z, &tmp_z, sizeof(tmp_z));
+ if (raw_z != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteFloatToArray(3, this->_internal_z(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.vec3)
+ return target;
+}
+
+size_t vec3::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.vec3)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // float x = 1;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_x = this->_internal_x();
+ uint32_t raw_x;
+ memcpy(&raw_x, &tmp_x, sizeof(tmp_x));
+ if (raw_x != 0) {
+ total_size += 1 + 4;
+ }
+
+ // float y = 2;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_y = this->_internal_y();
+ uint32_t raw_y;
+ memcpy(&raw_y, &tmp_y, sizeof(tmp_y));
+ if (raw_y != 0) {
+ total_size += 1 + 4;
+ }
+
+ // float z = 3;
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_z = this->_internal_z();
+ uint32_t raw_z;
+ memcpy(&raw_z, &tmp_z, sizeof(tmp_z));
+ if (raw_z != 0) {
+ total_size += 1 + 4;
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData vec3::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ vec3::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*vec3::GetClassData() const { return &_class_data_; }
+
+void vec3::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<vec3 *>(to)->MergeFrom(
+ static_cast<const vec3 &>(from));
+}
+
+
+void vec3::MergeFrom(const vec3& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.vec3)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_x = from._internal_x();
+ uint32_t raw_x;
+ memcpy(&raw_x, &tmp_x, sizeof(tmp_x));
+ if (raw_x != 0) {
+ _internal_set_x(from._internal_x());
+ }
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_y = from._internal_y();
+ uint32_t raw_y;
+ memcpy(&raw_y, &tmp_y, sizeof(tmp_y));
+ if (raw_y != 0) {
+ _internal_set_y(from._internal_y());
+ }
+ static_assert(sizeof(uint32_t) == sizeof(float), "Code assumes uint32_t and float are the same size.");
+ float tmp_z = from._internal_z();
+ uint32_t raw_z;
+ memcpy(&raw_z, &tmp_z, sizeof(tmp_z));
+ if (raw_z != 0) {
+ _internal_set_z(from._internal_z());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void vec3::CopyFrom(const vec3& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.vec3)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool vec3::IsInitialized() const {
+ return true;
+}
+
+void vec3::InternalSwap(vec3* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(vec3, z_)
+ + sizeof(vec3::z_)
+ - PROTOBUF_FIELD_OFFSET(vec3, x_)>(
+ reinterpret_cast<char*>(&x_),
+ reinterpret_cast<char*>(&other->x_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata vec3::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[2]);
+}
+
+// ===================================================================
+
+class ivec3::_Internal {
+ public:
+};
+
+ivec3::ivec3(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.ivec3)
+}
+ivec3::ivec3(const ivec3& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ ::memcpy(&x_, &from.x_,
+ static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ // @@protoc_insertion_point(copy_constructor:proto.ivec3)
+}
+
+inline void ivec3::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&x_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+}
+
+ivec3::~ivec3() {
+ // @@protoc_insertion_point(destructor:proto.ivec3)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void ivec3::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void ivec3::ArenaDtor(void* object) {
+ ivec3* _this = reinterpret_cast< ivec3* >(object);
+ (void)_this;
+}
+void ivec3::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void ivec3::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void ivec3::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.ivec3)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ ::memset(&x_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&z_) -
+ reinterpret_cast<char*>(&x_)) + sizeof(z_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* ivec3::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // int32 x = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ x_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // int32 y = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+ y_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // int32 z = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+ z_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* ivec3::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.ivec3)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // int32 x = 1;
+ if (this->_internal_x() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(1, this->_internal_x(), target);
+ }
+
+ // int32 y = 2;
+ if (this->_internal_y() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_y(), target);
+ }
+
+ // int32 z = 3;
+ if (this->_internal_z() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(3, this->_internal_z(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.ivec3)
+ return target;
+}
+
+size_t ivec3::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.ivec3)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // int32 x = 1;
+ if (this->_internal_x() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_x());
+ }
+
+ // int32 y = 2;
+ if (this->_internal_y() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_y());
+ }
+
+ // int32 z = 3;
+ if (this->_internal_z() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_z());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData ivec3::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ ivec3::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*ivec3::GetClassData() const { return &_class_data_; }
+
+void ivec3::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<ivec3 *>(to)->MergeFrom(
+ static_cast<const ivec3 &>(from));
+}
+
+
+void ivec3::MergeFrom(const ivec3& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.ivec3)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_x() != 0) {
+ _internal_set_x(from._internal_x());
+ }
+ if (from._internal_y() != 0) {
+ _internal_set_y(from._internal_y());
+ }
+ if (from._internal_z() != 0) {
+ _internal_set_z(from._internal_z());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void ivec3::CopyFrom(const ivec3& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.ivec3)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool ivec3::IsInitialized() const {
+ return true;
+}
+
+void ivec3::InternalSwap(ivec3* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(ivec3, z_)
+ + sizeof(ivec3::z_)
+ - PROTOBUF_FIELD_OFFSET(ivec3, x_)>(
+ reinterpret_cast<char*>(&x_),
+ reinterpret_cast<char*>(&other->x_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata ivec3::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[3]);
+}
+
+// ===================================================================
+
+class player::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const player* msg);
+ static const ::proto::vec3& local_pos(const player* msg);
+ static const ::proto::angles& viewangles(const player* msg);
+ static const ::proto::vec3& velocity(const player* msg);
+};
+
+const ::proto::coords&
+player::_Internal::chunk_pos(const player* msg) {
+ return *msg->chunk_pos_;
+}
+const ::proto::vec3&
+player::_Internal::local_pos(const player* msg) {
+ return *msg->local_pos_;
+}
+const ::proto::angles&
+player::_Internal::viewangles(const player* msg) {
+ return *msg->viewangles_;
+}
+const ::proto::vec3&
+player::_Internal::velocity(const player* msg) {
+ return *msg->velocity_;
+}
+player::player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.player)
+}
+player::player(const player& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ if (from._internal_has_local_pos()) {
+ local_pos_ = new ::proto::vec3(*from.local_pos_);
+ } else {
+ local_pos_ = nullptr;
+ }
+ if (from._internal_has_viewangles()) {
+ viewangles_ = new ::proto::angles(*from.viewangles_);
+ } else {
+ viewangles_ = nullptr;
+ }
+ if (from._internal_has_velocity()) {
+ velocity_ = new ::proto::vec3(*from.velocity_);
+ } else {
+ velocity_ = nullptr;
+ }
+ ::memcpy(&index_, &from.index_,
+ static_cast<size_t>(reinterpret_cast<char*>(&commands_) -
+ reinterpret_cast<char*>(&index_)) + sizeof(commands_));
+ // @@protoc_insertion_point(copy_constructor:proto.player)
+}
+
+inline void player::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&chunk_pos_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&commands_) -
+ reinterpret_cast<char*>(&chunk_pos_)) + sizeof(commands_));
+}
+
+player::~player() {
+ // @@protoc_insertion_point(destructor:proto.player)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void player::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+ if (this != internal_default_instance()) delete local_pos_;
+ if (this != internal_default_instance()) delete viewangles_;
+ if (this != internal_default_instance()) delete velocity_;
+}
+
+void player::ArenaDtor(void* object) {
+ player* _this = reinterpret_cast< player* >(object);
+ (void)_this;
+}
+void player::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void player::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void player::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.player)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && local_pos_ != nullptr) {
+ delete local_pos_;
+ }
+ local_pos_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && viewangles_ != nullptr) {
+ delete viewangles_;
+ }
+ viewangles_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && velocity_ != nullptr) {
+ delete velocity_;
+ }
+ velocity_ = nullptr;
+ ::memset(&index_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&commands_) -
+ reinterpret_cast<char*>(&index_)) + sizeof(commands_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* player::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint32 index = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // uint32 commands = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+ commands_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.coords chunk_pos = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.vec3 local_pos = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+ ptr = ctx->ParseMessage(_internal_mutable_local_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.angles viewangles = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+ ptr = ctx->ParseMessage(_internal_mutable_viewangles(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.vec3 velocity = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+ ptr = ctx->ParseMessage(_internal_mutable_velocity(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* player::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.player)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target);
+ }
+
+ // uint32 commands = 2;
+ if (this->_internal_commands() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(2, this->_internal_commands(), target);
+ }
+
+ // .proto.coords chunk_pos = 3;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 3, _Internal::chunk_pos(this), target, stream);
+ }
+
+ // .proto.vec3 local_pos = 4;
+ if (this->_internal_has_local_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 4, _Internal::local_pos(this), target, stream);
+ }
+
+ // .proto.angles viewangles = 5;
+ if (this->_internal_has_viewangles()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 5, _Internal::viewangles(this), target, stream);
+ }
+
+ // .proto.vec3 velocity = 6;
+ if (this->_internal_has_velocity()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 6, _Internal::velocity(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.player)
+ return target;
+}
+
+size_t player::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.player)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 3;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ // .proto.vec3 local_pos = 4;
+ if (this->_internal_has_local_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *local_pos_);
+ }
+
+ // .proto.angles viewangles = 5;
+ if (this->_internal_has_viewangles()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *viewangles_);
+ }
+
+ // .proto.vec3 velocity = 6;
+ if (this->_internal_has_velocity()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *velocity_);
+ }
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+ }
+
+ // uint32 commands = 2;
+ if (this->_internal_commands() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_commands());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData player::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ player::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*player::GetClassData() const { return &_class_data_; }
+
+void player::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<player *>(to)->MergeFrom(
+ static_cast<const player &>(from));
+}
+
+
+void player::MergeFrom(const player& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.player)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ if (from._internal_has_local_pos()) {
+ _internal_mutable_local_pos()->::proto::vec3::MergeFrom(from._internal_local_pos());
+ }
+ if (from._internal_has_viewangles()) {
+ _internal_mutable_viewangles()->::proto::angles::MergeFrom(from._internal_viewangles());
+ }
+ if (from._internal_has_velocity()) {
+ _internal_mutable_velocity()->::proto::vec3::MergeFrom(from._internal_velocity());
+ }
+ if (from._internal_index() != 0) {
+ _internal_set_index(from._internal_index());
+ }
+ if (from._internal_commands() != 0) {
+ _internal_set_commands(from._internal_commands());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void player::CopyFrom(const player& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.player)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool player::IsInitialized() const {
+ return true;
+}
+
+void player::InternalSwap(player* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(player, commands_)
+ + sizeof(player::commands_)
+ - PROTOBUF_FIELD_OFFSET(player, chunk_pos_)>(
+ reinterpret_cast<char*>(&chunk_pos_),
+ reinterpret_cast<char*>(&other->chunk_pos_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata player::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[4]);
+}
+
+// ===================================================================
+
+class auth::_Internal {
+ public:
+};
+
+auth::auth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.auth)
+}
+auth::auth(const auth& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (!from._internal_username().empty()) {
+ username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_username(),
+ GetArenaForAllocation());
+ }
+ password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (!from._internal_password().empty()) {
+ password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_password(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.auth)
+}
+
+inline void auth::SharedCtor() {
+username_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+password_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+auth::~auth() {
+ // @@protoc_insertion_point(destructor:proto.auth)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void auth::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ username_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ password_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void auth::ArenaDtor(void* object) {
+ auth* _this = reinterpret_cast< auth* >(object);
+ (void)_this;
+}
+void auth::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void auth::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void auth::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.auth)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ username_.ClearToEmpty();
+ password_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* auth::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // string username = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ auto str = _internal_mutable_username();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "proto.auth.username"));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // string password = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ auto str = _internal_mutable_password();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "proto.auth.password"));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* auth::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.auth)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string username = 1;
+ if (!this->_internal_username().empty()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_username().data(), static_cast<int>(this->_internal_username().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "proto.auth.username");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_username(), target);
+ }
+
+ // string password = 2;
+ if (!this->_internal_password().empty()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_password().data(), static_cast<int>(this->_internal_password().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "proto.auth.password");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_password(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.auth)
+ return target;
+}
+
+size_t auth::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.auth)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string username = 1;
+ if (!this->_internal_username().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_username());
+ }
+
+ // string password = 2;
+ if (!this->_internal_password().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_password());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData auth::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ auth::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*auth::GetClassData() const { return &_class_data_; }
+
+void auth::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<auth *>(to)->MergeFrom(
+ static_cast<const auth &>(from));
+}
+
+
+void auth::MergeFrom(const auth& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.auth)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_username().empty()) {
+ _internal_set_username(from._internal_username());
+ }
+ if (!from._internal_password().empty()) {
+ _internal_set_password(from._internal_password());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void auth::CopyFrom(const auth& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.auth)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool auth::IsInitialized() const {
+ return true;
+}
+
+void auth::InternalSwap(auth* other) {
+ using std::swap;
+ auto* lhs_arena = GetArenaForAllocation();
+ auto* rhs_arena = other->GetArenaForAllocation();
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &username_, lhs_arena,
+ &other->username_, rhs_arena
+ );
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &password_, lhs_arena,
+ &other->password_, rhs_arena
+ );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata auth::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[5]);
+}
+
+// ===================================================================
+
+class init::_Internal {
+ public:
+ static const ::proto::player& localplayer(const init* msg);
+};
+
+const ::proto::player&
+init::_Internal::localplayer(const init* msg) {
+ return *msg->localplayer_;
+}
+init::init(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.init)
+}
+init::init(const init& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_localplayer()) {
+ localplayer_ = new ::proto::player(*from.localplayer_);
+ } else {
+ localplayer_ = nullptr;
+ }
+ ::memcpy(&seed_, &from.seed_,
+ static_cast<size_t>(reinterpret_cast<char*>(&draw_distance_) -
+ reinterpret_cast<char*>(&seed_)) + sizeof(draw_distance_));
+ // @@protoc_insertion_point(copy_constructor:proto.init)
+}
+
+inline void init::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&localplayer_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&draw_distance_) -
+ reinterpret_cast<char*>(&localplayer_)) + sizeof(draw_distance_));
+}
+
+init::~init() {
+ // @@protoc_insertion_point(destructor:proto.init)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void init::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete localplayer_;
+}
+
+void init::ArenaDtor(void* object) {
+ init* _this = reinterpret_cast< init* >(object);
+ (void)_this;
+}
+void init::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void init::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void init::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.init)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && localplayer_ != nullptr) {
+ delete localplayer_;
+ }
+ localplayer_ = nullptr;
+ ::memset(&seed_, 0, static_cast<size_t>(
+ reinterpret_cast<char*>(&draw_distance_) -
+ reinterpret_cast<char*>(&seed_)) + sizeof(draw_distance_));
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* init::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint64 seed = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ seed_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // int32 draw_distance = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+ draw_distance_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.player localplayer = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+ ptr = ctx->ParseMessage(_internal_mutable_localplayer(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* init::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.init)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint64 seed = 1;
+ if (this->_internal_seed() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt64ToArray(1, this->_internal_seed(), target);
+ }
+
+ // int32 draw_distance = 2;
+ if (this->_internal_draw_distance() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteInt32ToArray(2, this->_internal_draw_distance(), target);
+ }
+
+ // .proto.player localplayer = 3;
+ if (this->_internal_has_localplayer()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 3, _Internal::localplayer(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.init)
+ return target;
+}
+
+size_t init::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.init)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.player localplayer = 3;
+ if (this->_internal_has_localplayer()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *localplayer_);
+ }
+
+ // uint64 seed = 1;
+ if (this->_internal_seed() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt64SizePlusOne(this->_internal_seed());
+ }
+
+ // int32 draw_distance = 2;
+ if (this->_internal_draw_distance() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32SizePlusOne(this->_internal_draw_distance());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData init::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ init::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*init::GetClassData() const { return &_class_data_; }
+
+void init::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<init *>(to)->MergeFrom(
+ static_cast<const init &>(from));
+}
+
+
+void init::MergeFrom(const init& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.init)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_localplayer()) {
+ _internal_mutable_localplayer()->::proto::player::MergeFrom(from._internal_localplayer());
+ }
+ if (from._internal_seed() != 0) {
+ _internal_set_seed(from._internal_seed());
+ }
+ if (from._internal_draw_distance() != 0) {
+ _internal_set_draw_distance(from._internal_draw_distance());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void init::CopyFrom(const init& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.init)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool init::IsInitialized() const {
+ return true;
+}
+
+void init::InternalSwap(init* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(init, draw_distance_)
+ + sizeof(init::draw_distance_)
+ - PROTOBUF_FIELD_OFFSET(init, localplayer_)>(
+ reinterpret_cast<char*>(&localplayer_),
+ reinterpret_cast<char*>(&other->localplayer_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata init::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[6]);
+}
+
+// ===================================================================
+
+class move::_Internal {
+ public:
+ static const ::proto::angles& viewangles(const move* msg);
+};
+
+const ::proto::angles&
+move::_Internal::viewangles(const move* msg) {
+ return *msg->viewangles_;
+}
+move::move(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.move)
+}
+move::move(const move& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_viewangles()) {
+ viewangles_ = new ::proto::angles(*from.viewangles_);
+ } else {
+ viewangles_ = nullptr;
+ }
+ commands_ = from.commands_;
+ // @@protoc_insertion_point(copy_constructor:proto.move)
+}
+
+inline void move::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&viewangles_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&commands_) -
+ reinterpret_cast<char*>(&viewangles_)) + sizeof(commands_));
+}
+
+move::~move() {
+ // @@protoc_insertion_point(destructor:proto.move)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void move::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete viewangles_;
+}
+
+void move::ArenaDtor(void* object) {
+ move* _this = reinterpret_cast< move* >(object);
+ (void)_this;
+}
+void move::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void move::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void move::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.move)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && viewangles_ != nullptr) {
+ delete viewangles_;
+ }
+ viewangles_ = nullptr;
+ commands_ = 0u;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* move::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint32 commands = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ commands_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.angles viewangles = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_viewangles(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* move::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.move)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint32 commands = 1;
+ if (this->_internal_commands() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_commands(), target);
+ }
+
+ // .proto.angles viewangles = 2;
+ if (this->_internal_has_viewangles()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::viewangles(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.move)
+ return target;
+}
+
+size_t move::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.move)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.angles viewangles = 2;
+ if (this->_internal_has_viewangles()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *viewangles_);
+ }
+
+ // uint32 commands = 1;
+ if (this->_internal_commands() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_commands());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData move::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ move::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*move::GetClassData() const { return &_class_data_; }
+
+void move::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<move *>(to)->MergeFrom(
+ static_cast<const move &>(from));
+}
+
+
+void move::MergeFrom(const move& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.move)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_viewangles()) {
+ _internal_mutable_viewangles()->::proto::angles::MergeFrom(from._internal_viewangles());
+ }
+ if (from._internal_commands() != 0) {
+ _internal_set_commands(from._internal_commands());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void move::CopyFrom(const move& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.move)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool move::IsInitialized() const {
+ return true;
+}
+
+void move::InternalSwap(move* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(move, commands_)
+ + sizeof(move::commands_)
+ - PROTOBUF_FIELD_OFFSET(move, viewangles_)>(
+ reinterpret_cast<char*>(&viewangles_),
+ reinterpret_cast<char*>(&other->viewangles_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata move::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[7]);
+}
+
+// ===================================================================
+
+class remove_player::_Internal {
+ public:
+};
+
+remove_player::remove_player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.remove_player)
+}
+remove_player::remove_player(const remove_player& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ index_ = from.index_;
+ // @@protoc_insertion_point(copy_constructor:proto.remove_player)
+}
+
+inline void remove_player::SharedCtor() {
+index_ = 0u;
+}
+
+remove_player::~remove_player() {
+ // @@protoc_insertion_point(destructor:proto.remove_player)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void remove_player::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+}
+
+void remove_player::ArenaDtor(void* object) {
+ remove_player* _this = reinterpret_cast< remove_player* >(object);
+ (void)_this;
+}
+void remove_player::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void remove_player::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void remove_player::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.remove_player)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ index_ = 0u;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* remove_player::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint32 index = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* remove_player::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.remove_player)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.remove_player)
+ return target;
+}
+
+size_t remove_player::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.remove_player)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData remove_player::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ remove_player::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*remove_player::GetClassData() const { return &_class_data_; }
+
+void remove_player::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<remove_player *>(to)->MergeFrom(
+ static_cast<const remove_player &>(from));
+}
+
+
+void remove_player::MergeFrom(const remove_player& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.remove_player)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_index() != 0) {
+ _internal_set_index(from._internal_index());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void remove_player::CopyFrom(const remove_player& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.remove_player)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool remove_player::IsInitialized() const {
+ return true;
+}
+
+void remove_player::InternalSwap(remove_player* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(index_, other->index_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata remove_player::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[8]);
+}
+
+// ===================================================================
+
+class say::_Internal {
+ public:
+};
+
+say::say(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.say)
+}
+say::say(const say& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (!from._internal_text().empty()) {
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_text(),
+ GetArenaForAllocation());
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.say)
+}
+
+inline void say::SharedCtor() {
+text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+}
+
+say::~say() {
+ // @@protoc_insertion_point(destructor:proto.say)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void say::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void say::ArenaDtor(void* object) {
+ say* _this = reinterpret_cast< say* >(object);
+ (void)_this;
+}
+void say::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void say::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void say::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.say)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ text_.ClearToEmpty();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* say::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // string text = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ auto str = _internal_mutable_text();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "proto.say.text"));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* say::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.say)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string text = 1;
+ if (!this->_internal_text().empty()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "proto.say.text");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_text(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.say)
+ return target;
+}
+
+size_t say::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.say)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string text = 1;
+ if (!this->_internal_text().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_text());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData say::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ say::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*say::GetClassData() const { return &_class_data_; }
+
+void say::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<say *>(to)->MergeFrom(
+ static_cast<const say &>(from));
+}
+
+
+void say::MergeFrom(const say& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.say)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_text().empty()) {
+ _internal_set_text(from._internal_text());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void say::CopyFrom(const say& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.say)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool say::IsInitialized() const {
+ return true;
+}
+
+void say::InternalSwap(say* other) {
+ using std::swap;
+ auto* lhs_arena = GetArenaForAllocation();
+ auto* rhs_arena = other->GetArenaForAllocation();
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &text_, lhs_arena,
+ &other->text_, rhs_arena
+ );
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata say::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[9]);
+}
+
+// ===================================================================
+
+class hear_player::_Internal {
+ public:
+};
+
+hear_player::hear_player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.hear_player)
+}
+hear_player::hear_player(const hear_player& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (!from._internal_text().empty()) {
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_text(),
+ GetArenaForAllocation());
+ }
+ index_ = from.index_;
+ // @@protoc_insertion_point(copy_constructor:proto.hear_player)
+}
+
+inline void hear_player::SharedCtor() {
+text_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+index_ = 0u;
+}
+
+hear_player::~hear_player() {
+ // @@protoc_insertion_point(destructor:proto.hear_player)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void hear_player::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ text_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void hear_player::ArenaDtor(void* object) {
+ hear_player* _this = reinterpret_cast< hear_player* >(object);
+ (void)_this;
+}
+void hear_player::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void hear_player::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void hear_player::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.hear_player)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ text_.ClearToEmpty();
+ index_ = 0u;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* hear_player::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // uint32 index = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 8)) {
+ index_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // string text = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ auto str = _internal_mutable_text();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "proto.hear_player.text"));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* hear_player::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.hear_player)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(1, this->_internal_index(), target);
+ }
+
+ // string text = 2;
+ if (!this->_internal_text().empty()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_text().data(), static_cast<int>(this->_internal_text().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "proto.hear_player.text");
+ target = stream->WriteStringMaybeAliased(
+ 2, this->_internal_text(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.hear_player)
+ return target;
+}
+
+size_t hear_player::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.hear_player)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string text = 2;
+ if (!this->_internal_text().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_text());
+ }
+
+ // uint32 index = 1;
+ if (this->_internal_index() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_index());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData hear_player::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ hear_player::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*hear_player::GetClassData() const { return &_class_data_; }
+
+void hear_player::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<hear_player *>(to)->MergeFrom(
+ static_cast<const hear_player &>(from));
+}
+
+
+void hear_player::MergeFrom(const hear_player& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.hear_player)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_text().empty()) {
+ _internal_set_text(from._internal_text());
+ }
+ if (from._internal_index() != 0) {
+ _internal_set_index(from._internal_index());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void hear_player::CopyFrom(const hear_player& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.hear_player)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool hear_player::IsInitialized() const {
+ return true;
+}
+
+void hear_player::InternalSwap(hear_player* other) {
+ using std::swap;
+ auto* lhs_arena = GetArenaForAllocation();
+ auto* rhs_arena = other->GetArenaForAllocation();
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &text_, lhs_arena,
+ &other->text_, rhs_arena
+ );
+ swap(index_, other->index_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata hear_player::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[10]);
+}
+
+// ===================================================================
+
+class request_chunk::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const request_chunk* msg);
+};
+
+const ::proto::coords&
+request_chunk::_Internal::chunk_pos(const request_chunk* msg) {
+ return *msg->chunk_pos_;
+}
+request_chunk::request_chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.request_chunk)
+}
+request_chunk::request_chunk(const request_chunk& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.request_chunk)
+}
+
+inline void request_chunk::SharedCtor() {
+chunk_pos_ = nullptr;
+}
+
+request_chunk::~request_chunk() {
+ // @@protoc_insertion_point(destructor:proto.request_chunk)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void request_chunk::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+}
+
+void request_chunk::ArenaDtor(void* object) {
+ request_chunk* _this = reinterpret_cast< request_chunk* >(object);
+ (void)_this;
+}
+void request_chunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void request_chunk::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void request_chunk::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.request_chunk)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* request_chunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.coords chunk_pos = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* request_chunk::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.request_chunk)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::chunk_pos(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.request_chunk)
+ return target;
+}
+
+size_t request_chunk::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.request_chunk)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData request_chunk::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ request_chunk::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*request_chunk::GetClassData() const { return &_class_data_; }
+
+void request_chunk::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<request_chunk *>(to)->MergeFrom(
+ static_cast<const request_chunk &>(from));
+}
+
+
+void request_chunk::MergeFrom(const request_chunk& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.request_chunk)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void request_chunk::CopyFrom(const request_chunk& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.request_chunk)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool request_chunk::IsInitialized() const {
+ return true;
+}
+
+void request_chunk::InternalSwap(request_chunk* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(chunk_pos_, other->chunk_pos_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata request_chunk::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[11]);
+}
+
+// ===================================================================
+
+class remove_chunk::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const remove_chunk* msg);
+};
+
+const ::proto::coords&
+remove_chunk::_Internal::chunk_pos(const remove_chunk* msg) {
+ return *msg->chunk_pos_;
+}
+remove_chunk::remove_chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.remove_chunk)
+}
+remove_chunk::remove_chunk(const remove_chunk& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.remove_chunk)
+}
+
+inline void remove_chunk::SharedCtor() {
+chunk_pos_ = nullptr;
+}
+
+remove_chunk::~remove_chunk() {
+ // @@protoc_insertion_point(destructor:proto.remove_chunk)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void remove_chunk::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+}
+
+void remove_chunk::ArenaDtor(void* object) {
+ remove_chunk* _this = reinterpret_cast< remove_chunk* >(object);
+ (void)_this;
+}
+void remove_chunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void remove_chunk::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void remove_chunk::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.remove_chunk)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* remove_chunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.coords chunk_pos = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* remove_chunk::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.remove_chunk)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::chunk_pos(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.remove_chunk)
+ return target;
+}
+
+size_t remove_chunk::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.remove_chunk)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData remove_chunk::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ remove_chunk::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*remove_chunk::GetClassData() const { return &_class_data_; }
+
+void remove_chunk::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<remove_chunk *>(to)->MergeFrom(
+ static_cast<const remove_chunk &>(from));
+}
+
+
+void remove_chunk::MergeFrom(const remove_chunk& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.remove_chunk)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void remove_chunk::CopyFrom(const remove_chunk& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.remove_chunk)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool remove_chunk::IsInitialized() const {
+ return true;
+}
+
+void remove_chunk::InternalSwap(remove_chunk* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(chunk_pos_, other->chunk_pos_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata remove_chunk::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[12]);
+}
+
+// ===================================================================
+
+class chunk::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const chunk* msg);
+};
+
+const ::proto::coords&
+chunk::_Internal::chunk_pos(const chunk* msg) {
+ return *msg->chunk_pos_;
+}
+chunk::chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned),
+ blocks_(arena) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.chunk)
+}
+chunk::chunk(const chunk& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message(),
+ blocks_(from.blocks_) {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.chunk)
+}
+
+inline void chunk::SharedCtor() {
+chunk_pos_ = nullptr;
+}
+
+chunk::~chunk() {
+ // @@protoc_insertion_point(destructor:proto.chunk)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void chunk::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+}
+
+void chunk::ArenaDtor(void* object) {
+ chunk* _this = reinterpret_cast< chunk* >(object);
+ (void)_this;
+}
+void chunk::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void chunk::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void chunk::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.chunk)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ blocks_.Clear();
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* chunk::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.coords chunk_pos = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // repeated uint32 blocks = 2 [packed = true];
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedUInt32Parser(_internal_mutable_blocks(), ptr, ctx);
+ CHK_(ptr);
+ } else if (static_cast<uint8_t>(tag) == 16) {
+ _internal_add_blocks(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* chunk::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.chunk)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::chunk_pos(this), target, stream);
+ }
+
+ // repeated uint32 blocks = 2 [packed = true];
+ {
+ int byte_size = _blocks_cached_byte_size_.load(std::memory_order_relaxed);
+ if (byte_size > 0) {
+ target = stream->WriteUInt32Packed(
+ 2, _internal_blocks(), byte_size, target);
+ }
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.chunk)
+ return target;
+}
+
+size_t chunk::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.chunk)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // repeated uint32 blocks = 2 [packed = true];
+ {
+ size_t data_size = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ UInt32Size(this->blocks_);
+ if (data_size > 0) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::Int32Size(
+ static_cast<int32_t>(data_size));
+ }
+ int cached_size = ::PROTOBUF_NAMESPACE_ID::internal::ToCachedSize(data_size);
+ _blocks_cached_byte_size_.store(cached_size,
+ std::memory_order_relaxed);
+ total_size += data_size;
+ }
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData chunk::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ chunk::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*chunk::GetClassData() const { return &_class_data_; }
+
+void chunk::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<chunk *>(to)->MergeFrom(
+ static_cast<const chunk &>(from));
+}
+
+
+void chunk::MergeFrom(const chunk& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.chunk)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ blocks_.MergeFrom(from.blocks_);
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void chunk::CopyFrom(const chunk& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.chunk)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool chunk::IsInitialized() const {
+ return true;
+}
+
+void chunk::InternalSwap(chunk* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ blocks_.InternalSwap(&other->blocks_);
+ swap(chunk_pos_, other->chunk_pos_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata chunk::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[13]);
+}
+
+// ===================================================================
+
+class add_block::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const add_block* msg);
+ static const ::proto::ivec3& block_pos(const add_block* msg);
+};
+
+const ::proto::coords&
+add_block::_Internal::chunk_pos(const add_block* msg) {
+ return *msg->chunk_pos_;
+}
+const ::proto::ivec3&
+add_block::_Internal::block_pos(const add_block* msg) {
+ return *msg->block_pos_;
+}
+add_block::add_block(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.add_block)
+}
+add_block::add_block(const add_block& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ if (from._internal_has_block_pos()) {
+ block_pos_ = new ::proto::ivec3(*from.block_pos_);
+ } else {
+ block_pos_ = nullptr;
+ }
+ block_ = from.block_;
+ // @@protoc_insertion_point(copy_constructor:proto.add_block)
+}
+
+inline void add_block::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&chunk_pos_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&block_) -
+ reinterpret_cast<char*>(&chunk_pos_)) + sizeof(block_));
+}
+
+add_block::~add_block() {
+ // @@protoc_insertion_point(destructor:proto.add_block)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void add_block::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+ if (this != internal_default_instance()) delete block_pos_;
+}
+
+void add_block::ArenaDtor(void* object) {
+ add_block* _this = reinterpret_cast< add_block* >(object);
+ (void)_this;
+}
+void add_block::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void add_block::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void add_block::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.add_block)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && block_pos_ != nullptr) {
+ delete block_pos_;
+ }
+ block_pos_ = nullptr;
+ block_ = 0u;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* add_block::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.coords chunk_pos = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.ivec3 block_pos = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_block_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // uint32 block = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 24)) {
+ block_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint32(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* add_block::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.add_block)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::chunk_pos(this), target, stream);
+ }
+
+ // .proto.ivec3 block_pos = 2;
+ if (this->_internal_has_block_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::block_pos(this), target, stream);
+ }
+
+ // uint32 block = 3;
+ if (this->_internal_block() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteUInt32ToArray(3, this->_internal_block(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.add_block)
+ return target;
+}
+
+size_t add_block::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.add_block)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ // .proto.ivec3 block_pos = 2;
+ if (this->_internal_has_block_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *block_pos_);
+ }
+
+ // uint32 block = 3;
+ if (this->_internal_block() != 0) {
+ total_size += ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::UInt32SizePlusOne(this->_internal_block());
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData add_block::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ add_block::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*add_block::GetClassData() const { return &_class_data_; }
+
+void add_block::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<add_block *>(to)->MergeFrom(
+ static_cast<const add_block &>(from));
+}
+
+
+void add_block::MergeFrom(const add_block& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.add_block)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ if (from._internal_has_block_pos()) {
+ _internal_mutable_block_pos()->::proto::ivec3::MergeFrom(from._internal_block_pos());
+ }
+ if (from._internal_block() != 0) {
+ _internal_set_block(from._internal_block());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void add_block::CopyFrom(const add_block& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.add_block)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool add_block::IsInitialized() const {
+ return true;
+}
+
+void add_block::InternalSwap(add_block* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(add_block, block_)
+ + sizeof(add_block::block_)
+ - PROTOBUF_FIELD_OFFSET(add_block, chunk_pos_)>(
+ reinterpret_cast<char*>(&chunk_pos_),
+ reinterpret_cast<char*>(&other->chunk_pos_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata add_block::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[14]);
+}
+
+// ===================================================================
+
+class remove_block::_Internal {
+ public:
+ static const ::proto::coords& chunk_pos(const remove_block* msg);
+ static const ::proto::ivec3& block_pos(const remove_block* msg);
+};
+
+const ::proto::coords&
+remove_block::_Internal::chunk_pos(const remove_block* msg) {
+ return *msg->chunk_pos_;
+}
+const ::proto::ivec3&
+remove_block::_Internal::block_pos(const remove_block* msg) {
+ return *msg->block_pos_;
+}
+remove_block::remove_block(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.remove_block)
+}
+remove_block::remove_block(const remove_block& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ if (from._internal_has_chunk_pos()) {
+ chunk_pos_ = new ::proto::coords(*from.chunk_pos_);
+ } else {
+ chunk_pos_ = nullptr;
+ }
+ if (from._internal_has_block_pos()) {
+ block_pos_ = new ::proto::ivec3(*from.block_pos_);
+ } else {
+ block_pos_ = nullptr;
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.remove_block)
+}
+
+inline void remove_block::SharedCtor() {
+::memset(reinterpret_cast<char*>(this) + static_cast<size_t>(
+ reinterpret_cast<char*>(&chunk_pos_) - reinterpret_cast<char*>(this)),
+ 0, static_cast<size_t>(reinterpret_cast<char*>(&block_pos_) -
+ reinterpret_cast<char*>(&chunk_pos_)) + sizeof(block_pos_));
+}
+
+remove_block::~remove_block() {
+ // @@protoc_insertion_point(destructor:proto.remove_block)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void remove_block::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (this != internal_default_instance()) delete chunk_pos_;
+ if (this != internal_default_instance()) delete block_pos_;
+}
+
+void remove_block::ArenaDtor(void* object) {
+ remove_block* _this = reinterpret_cast< remove_block* >(object);
+ (void)_this;
+}
+void remove_block::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void remove_block::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void remove_block::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.remove_block)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+ if (GetArenaForAllocation() == nullptr && block_pos_ != nullptr) {
+ delete block_pos_;
+ }
+ block_pos_ = nullptr;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* remove_block::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.coords chunk_pos = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.ivec3 block_pos = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_block_pos(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* remove_block::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.remove_block)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::chunk_pos(this), target, stream);
+ }
+
+ // .proto.ivec3 block_pos = 2;
+ if (this->_internal_has_block_pos()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::block_pos(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.remove_block)
+ return target;
+}
+
+size_t remove_block::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.remove_block)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // .proto.coords chunk_pos = 1;
+ if (this->_internal_has_chunk_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *chunk_pos_);
+ }
+
+ // .proto.ivec3 block_pos = 2;
+ if (this->_internal_has_block_pos()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *block_pos_);
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData remove_block::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ remove_block::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*remove_block::GetClassData() const { return &_class_data_; }
+
+void remove_block::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<remove_block *>(to)->MergeFrom(
+ static_cast<const remove_block &>(from));
+}
+
+
+void remove_block::MergeFrom(const remove_block& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.remove_block)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (from._internal_has_chunk_pos()) {
+ _internal_mutable_chunk_pos()->::proto::coords::MergeFrom(from._internal_chunk_pos());
+ }
+ if (from._internal_has_block_pos()) {
+ _internal_mutable_block_pos()->::proto::ivec3::MergeFrom(from._internal_block_pos());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void remove_block::CopyFrom(const remove_block& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.remove_block)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool remove_block::IsInitialized() const {
+ return true;
+}
+
+void remove_block::InternalSwap(remove_block* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::memswap<
+ PROTOBUF_FIELD_OFFSET(remove_block, block_pos_)
+ + sizeof(remove_block::block_pos_)
+ - PROTOBUF_FIELD_OFFSET(remove_block, chunk_pos_)>(
+ reinterpret_cast<char*>(&chunk_pos_),
+ reinterpret_cast<char*>(&other->chunk_pos_));
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata remove_block::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[15]);
+}
+
+// ===================================================================
+
+class server_message::_Internal {
+ public:
+};
+
+server_message::server_message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.server_message)
+}
+server_message::server_message(const server_message& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+ #ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ #endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (!from._internal_message().empty()) {
+ message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_message(),
+ GetArenaForAllocation());
+ }
+ fatal_ = from.fatal_;
+ // @@protoc_insertion_point(copy_constructor:proto.server_message)
+}
+
+inline void server_message::SharedCtor() {
+message_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+fatal_ = false;
+}
+
+server_message::~server_message() {
+ // @@protoc_insertion_point(destructor:proto.server_message)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void server_message::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ message_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+}
+
+void server_message::ArenaDtor(void* object) {
+ server_message* _this = reinterpret_cast< server_message* >(object);
+ (void)_this;
+}
+void server_message::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void server_message::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void server_message::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.server_message)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ message_.ClearToEmpty();
+ fatal_ = false;
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* server_message::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // string message = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ auto str = _internal_mutable_message();
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx);
+ CHK_(::PROTOBUF_NAMESPACE_ID::internal::VerifyUTF8(str, "proto.server_message.message"));
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // bool fatal = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 16)) {
+ fatal_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* server_message::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.server_message)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // string message = 1;
+ if (!this->_internal_message().empty()) {
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(
+ this->_internal_message().data(), static_cast<int>(this->_internal_message().length()),
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::SERIALIZE,
+ "proto.server_message.message");
+ target = stream->WriteStringMaybeAliased(
+ 1, this->_internal_message(), target);
+ }
+
+ // bool fatal = 2;
+ if (this->_internal_fatal() != 0) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::WriteBoolToArray(2, this->_internal_fatal(), target);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.server_message)
+ return target;
+}
+
+size_t server_message::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.server_message)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ // string message = 1;
+ if (!this->_internal_message().empty()) {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::StringSize(
+ this->_internal_message());
+ }
+
+ // bool fatal = 2;
+ if (this->_internal_fatal() != 0) {
+ total_size += 1 + 1;
+ }
+
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData server_message::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ server_message::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*server_message::GetClassData() const { return &_class_data_; }
+
+void server_message::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<server_message *>(to)->MergeFrom(
+ static_cast<const server_message &>(from));
+}
+
+
+void server_message::MergeFrom(const server_message& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.server_message)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ if (!from._internal_message().empty()) {
+ _internal_set_message(from._internal_message());
+ }
+ if (from._internal_fatal() != 0) {
+ _internal_set_fatal(from._internal_fatal());
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void server_message::CopyFrom(const server_message& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.server_message)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool server_message::IsInitialized() const {
+ return true;
+}
+
+void server_message::InternalSwap(server_message* other) {
+ using std::swap;
+ auto* lhs_arena = GetArenaForAllocation();
+ auto* rhs_arena = other->GetArenaForAllocation();
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::InternalSwap(
+ &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
+ &message_, lhs_arena,
+ &other->message_, rhs_arena
+ );
+ swap(fatal_, other->fatal_);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata server_message::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[16]);
+}
+
+// ===================================================================
+
+class packet::_Internal {
+ public:
+ static const ::proto::auth& auth_packet(const packet* msg);
+ static const ::proto::init& init_packet(const packet* msg);
+ static const ::proto::move& move_packet(const packet* msg);
+ static const ::proto::player& player_packet(const packet* msg);
+ static const ::proto::remove_player& remove_player_packet(const packet* msg);
+ static const ::proto::say& say_packet(const packet* msg);
+ static const ::proto::hear_player& hear_player_packet(const packet* msg);
+ static const ::proto::request_chunk& request_chunk_packet(const packet* msg);
+ static const ::proto::chunk& chunk_packet(const packet* msg);
+ static const ::proto::remove_chunk& remove_chunk_packet(const packet* msg);
+ static const ::proto::add_block& add_block_packet(const packet* msg);
+ static const ::proto::remove_block& remove_block_packet(const packet* msg);
+ static const ::proto::server_message& server_message_packet(const packet* msg);
+};
+
+const ::proto::auth&
+packet::_Internal::auth_packet(const packet* msg) {
+ return *msg->contents_.auth_packet_;
+}
+const ::proto::init&
+packet::_Internal::init_packet(const packet* msg) {
+ return *msg->contents_.init_packet_;
+}
+const ::proto::move&
+packet::_Internal::move_packet(const packet* msg) {
+ return *msg->contents_.move_packet_;
+}
+const ::proto::player&
+packet::_Internal::player_packet(const packet* msg) {
+ return *msg->contents_.player_packet_;
+}
+const ::proto::remove_player&
+packet::_Internal::remove_player_packet(const packet* msg) {
+ return *msg->contents_.remove_player_packet_;
+}
+const ::proto::say&
+packet::_Internal::say_packet(const packet* msg) {
+ return *msg->contents_.say_packet_;
+}
+const ::proto::hear_player&
+packet::_Internal::hear_player_packet(const packet* msg) {
+ return *msg->contents_.hear_player_packet_;
+}
+const ::proto::request_chunk&
+packet::_Internal::request_chunk_packet(const packet* msg) {
+ return *msg->contents_.request_chunk_packet_;
+}
+const ::proto::chunk&
+packet::_Internal::chunk_packet(const packet* msg) {
+ return *msg->contents_.chunk_packet_;
+}
+const ::proto::remove_chunk&
+packet::_Internal::remove_chunk_packet(const packet* msg) {
+ return *msg->contents_.remove_chunk_packet_;
+}
+const ::proto::add_block&
+packet::_Internal::add_block_packet(const packet* msg) {
+ return *msg->contents_.add_block_packet_;
+}
+const ::proto::remove_block&
+packet::_Internal::remove_block_packet(const packet* msg) {
+ return *msg->contents_.remove_block_packet_;
+}
+const ::proto::server_message&
+packet::_Internal::server_message_packet(const packet* msg) {
+ return *msg->contents_.server_message_packet_;
+}
+void packet::set_allocated_auth_packet(::proto::auth* auth_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (auth_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::auth>::GetOwningArena(auth_packet);
+ if (message_arena != submessage_arena) {
+ auth_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, auth_packet, submessage_arena);
+ }
+ set_has_auth_packet();
+ contents_.auth_packet_ = auth_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.auth_packet)
+}
+void packet::set_allocated_init_packet(::proto::init* init_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (init_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::init>::GetOwningArena(init_packet);
+ if (message_arena != submessage_arena) {
+ init_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, init_packet, submessage_arena);
+ }
+ set_has_init_packet();
+ contents_.init_packet_ = init_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.init_packet)
+}
+void packet::set_allocated_move_packet(::proto::move* move_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (move_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::move>::GetOwningArena(move_packet);
+ if (message_arena != submessage_arena) {
+ move_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, move_packet, submessage_arena);
+ }
+ set_has_move_packet();
+ contents_.move_packet_ = move_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.move_packet)
+}
+void packet::set_allocated_player_packet(::proto::player* player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::player>::GetOwningArena(player_packet);
+ if (message_arena != submessage_arena) {
+ player_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, player_packet, submessage_arena);
+ }
+ set_has_player_packet();
+ contents_.player_packet_ = player_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.player_packet)
+}
+void packet::set_allocated_remove_player_packet(::proto::remove_player* remove_player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (remove_player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::remove_player>::GetOwningArena(remove_player_packet);
+ if (message_arena != submessage_arena) {
+ remove_player_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, remove_player_packet, submessage_arena);
+ }
+ set_has_remove_player_packet();
+ contents_.remove_player_packet_ = remove_player_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.remove_player_packet)
+}
+void packet::set_allocated_say_packet(::proto::say* say_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (say_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::say>::GetOwningArena(say_packet);
+ if (message_arena != submessage_arena) {
+ say_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, say_packet, submessage_arena);
+ }
+ set_has_say_packet();
+ contents_.say_packet_ = say_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.say_packet)
+}
+void packet::set_allocated_hear_player_packet(::proto::hear_player* hear_player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (hear_player_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::hear_player>::GetOwningArena(hear_player_packet);
+ if (message_arena != submessage_arena) {
+ hear_player_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, hear_player_packet, submessage_arena);
+ }
+ set_has_hear_player_packet();
+ contents_.hear_player_packet_ = hear_player_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.hear_player_packet)
+}
+void packet::set_allocated_request_chunk_packet(::proto::request_chunk* request_chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (request_chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::request_chunk>::GetOwningArena(request_chunk_packet);
+ if (message_arena != submessage_arena) {
+ request_chunk_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, request_chunk_packet, submessage_arena);
+ }
+ set_has_request_chunk_packet();
+ contents_.request_chunk_packet_ = request_chunk_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.request_chunk_packet)
+}
+void packet::set_allocated_chunk_packet(::proto::chunk* chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::chunk>::GetOwningArena(chunk_packet);
+ if (message_arena != submessage_arena) {
+ chunk_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_packet, submessage_arena);
+ }
+ set_has_chunk_packet();
+ contents_.chunk_packet_ = chunk_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.chunk_packet)
+}
+void packet::set_allocated_remove_chunk_packet(::proto::remove_chunk* remove_chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (remove_chunk_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::remove_chunk>::GetOwningArena(remove_chunk_packet);
+ if (message_arena != submessage_arena) {
+ remove_chunk_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, remove_chunk_packet, submessage_arena);
+ }
+ set_has_remove_chunk_packet();
+ contents_.remove_chunk_packet_ = remove_chunk_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.remove_chunk_packet)
+}
+void packet::set_allocated_add_block_packet(::proto::add_block* add_block_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (add_block_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::add_block>::GetOwningArena(add_block_packet);
+ if (message_arena != submessage_arena) {
+ add_block_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, add_block_packet, submessage_arena);
+ }
+ set_has_add_block_packet();
+ contents_.add_block_packet_ = add_block_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.add_block_packet)
+}
+void packet::set_allocated_remove_block_packet(::proto::remove_block* remove_block_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (remove_block_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::remove_block>::GetOwningArena(remove_block_packet);
+ if (message_arena != submessage_arena) {
+ remove_block_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, remove_block_packet, submessage_arena);
+ }
+ set_has_remove_block_packet();
+ contents_.remove_block_packet_ = remove_block_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.remove_block_packet)
+}
+void packet::set_allocated_server_message_packet(::proto::server_message* server_message_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ clear_contents();
+ if (server_message_packet) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::server_message>::GetOwningArena(server_message_packet);
+ if (message_arena != submessage_arena) {
+ server_message_packet = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, server_message_packet, submessage_arena);
+ }
+ set_has_server_message_packet();
+ contents_.server_message_packet_ = server_message_packet;
+ }
+ // @@protoc_insertion_point(field_set_allocated:proto.packet.server_message_packet)
+}
+packet::packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned)
+ : ::PROTOBUF_NAMESPACE_ID::Message(arena, is_message_owned) {
+ SharedCtor();
+ if (!is_message_owned) {
+ RegisterArenaDtor(arena);
+ }
+ // @@protoc_insertion_point(arena_constructor:proto.packet)
+}
+packet::packet(const packet& from)
+ : ::PROTOBUF_NAMESPACE_ID::Message() {
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+ clear_has_contents();
+ switch (from.contents_case()) {
+ case kAuthPacket: {
+ _internal_mutable_auth_packet()->::proto::auth::MergeFrom(from._internal_auth_packet());
+ break;
+ }
+ case kInitPacket: {
+ _internal_mutable_init_packet()->::proto::init::MergeFrom(from._internal_init_packet());
+ break;
+ }
+ case kMovePacket: {
+ _internal_mutable_move_packet()->::proto::move::MergeFrom(from._internal_move_packet());
+ break;
+ }
+ case kPlayerPacket: {
+ _internal_mutable_player_packet()->::proto::player::MergeFrom(from._internal_player_packet());
+ break;
+ }
+ case kRemovePlayerPacket: {
+ _internal_mutable_remove_player_packet()->::proto::remove_player::MergeFrom(from._internal_remove_player_packet());
+ break;
+ }
+ case kSayPacket: {
+ _internal_mutable_say_packet()->::proto::say::MergeFrom(from._internal_say_packet());
+ break;
+ }
+ case kHearPlayerPacket: {
+ _internal_mutable_hear_player_packet()->::proto::hear_player::MergeFrom(from._internal_hear_player_packet());
+ break;
+ }
+ case kRequestChunkPacket: {
+ _internal_mutable_request_chunk_packet()->::proto::request_chunk::MergeFrom(from._internal_request_chunk_packet());
+ break;
+ }
+ case kChunkPacket: {
+ _internal_mutable_chunk_packet()->::proto::chunk::MergeFrom(from._internal_chunk_packet());
+ break;
+ }
+ case kRemoveChunkPacket: {
+ _internal_mutable_remove_chunk_packet()->::proto::remove_chunk::MergeFrom(from._internal_remove_chunk_packet());
+ break;
+ }
+ case kAddBlockPacket: {
+ _internal_mutable_add_block_packet()->::proto::add_block::MergeFrom(from._internal_add_block_packet());
+ break;
+ }
+ case kRemoveBlockPacket: {
+ _internal_mutable_remove_block_packet()->::proto::remove_block::MergeFrom(from._internal_remove_block_packet());
+ break;
+ }
+ case kServerMessagePacket: {
+ _internal_mutable_server_message_packet()->::proto::server_message::MergeFrom(from._internal_server_message_packet());
+ break;
+ }
+ case CONTENTS_NOT_SET: {
+ break;
+ }
+ }
+ // @@protoc_insertion_point(copy_constructor:proto.packet)
+}
+
+inline void packet::SharedCtor() {
+clear_has_contents();
+}
+
+packet::~packet() {
+ // @@protoc_insertion_point(destructor:proto.packet)
+ if (GetArenaForAllocation() != nullptr) return;
+ SharedDtor();
+ _internal_metadata_.Delete<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+inline void packet::SharedDtor() {
+ GOOGLE_DCHECK(GetArenaForAllocation() == nullptr);
+ if (has_contents()) {
+ clear_contents();
+ }
+}
+
+void packet::ArenaDtor(void* object) {
+ packet* _this = reinterpret_cast< packet* >(object);
+ (void)_this;
+}
+void packet::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) {
+}
+void packet::SetCachedSize(int size) const {
+ _cached_size_.Set(size);
+}
+
+void packet::clear_contents() {
+// @@protoc_insertion_point(one_of_clear_start:proto.packet)
+ switch (contents_case()) {
+ case kAuthPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.auth_packet_;
+ }
+ break;
+ }
+ case kInitPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.init_packet_;
+ }
+ break;
+ }
+ case kMovePacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.move_packet_;
+ }
+ break;
+ }
+ case kPlayerPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.player_packet_;
+ }
+ break;
+ }
+ case kRemovePlayerPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_player_packet_;
+ }
+ break;
+ }
+ case kSayPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.say_packet_;
+ }
+ break;
+ }
+ case kHearPlayerPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.hear_player_packet_;
+ }
+ break;
+ }
+ case kRequestChunkPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.request_chunk_packet_;
+ }
+ break;
+ }
+ case kChunkPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.chunk_packet_;
+ }
+ break;
+ }
+ case kRemoveChunkPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_chunk_packet_;
+ }
+ break;
+ }
+ case kAddBlockPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.add_block_packet_;
+ }
+ break;
+ }
+ case kRemoveBlockPacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_block_packet_;
+ }
+ break;
+ }
+ case kServerMessagePacket: {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.server_message_packet_;
+ }
+ break;
+ }
+ case CONTENTS_NOT_SET: {
+ break;
+ }
+ }
+ _oneof_case_[0] = CONTENTS_NOT_SET;
+}
+
+
+void packet::Clear() {
+// @@protoc_insertion_point(message_clear_start:proto.packet)
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ clear_contents();
+ _internal_metadata_.Clear<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+}
+
+const char* packet::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) {
+#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure
+ while (!ctx->Done(&ptr)) {
+ uint32_t tag;
+ ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag);
+ switch (tag >> 3) {
+ // .proto.auth auth_packet = 1;
+ case 1:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 10)) {
+ ptr = ctx->ParseMessage(_internal_mutable_auth_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.init init_packet = 2;
+ case 2:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 18)) {
+ ptr = ctx->ParseMessage(_internal_mutable_init_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.move move_packet = 3;
+ case 3:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 26)) {
+ ptr = ctx->ParseMessage(_internal_mutable_move_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.player player_packet = 4;
+ case 4:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 34)) {
+ ptr = ctx->ParseMessage(_internal_mutable_player_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.remove_player remove_player_packet = 5;
+ case 5:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 42)) {
+ ptr = ctx->ParseMessage(_internal_mutable_remove_player_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.say say_packet = 6;
+ case 6:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 50)) {
+ ptr = ctx->ParseMessage(_internal_mutable_say_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.hear_player hear_player_packet = 7;
+ case 7:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 58)) {
+ ptr = ctx->ParseMessage(_internal_mutable_hear_player_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.request_chunk request_chunk_packet = 8;
+ case 8:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 66)) {
+ ptr = ctx->ParseMessage(_internal_mutable_request_chunk_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.chunk chunk_packet = 9;
+ case 9:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 74)) {
+ ptr = ctx->ParseMessage(_internal_mutable_chunk_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.remove_chunk remove_chunk_packet = 10;
+ case 10:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 82)) {
+ ptr = ctx->ParseMessage(_internal_mutable_remove_chunk_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.add_block add_block_packet = 11;
+ case 11:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 90)) {
+ ptr = ctx->ParseMessage(_internal_mutable_add_block_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.remove_block remove_block_packet = 12;
+ case 12:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 98)) {
+ ptr = ctx->ParseMessage(_internal_mutable_remove_block_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ // .proto.server_message server_message_packet = 13;
+ case 13:
+ if (PROTOBUF_PREDICT_TRUE(static_cast<uint8_t>(tag) == 106)) {
+ ptr = ctx->ParseMessage(_internal_mutable_server_message_packet(), ptr);
+ CHK_(ptr);
+ } else
+ goto handle_unusual;
+ continue;
+ default:
+ goto handle_unusual;
+ } // switch
+ handle_unusual:
+ if ((tag == 0) || ((tag & 7) == 4)) {
+ CHK_(ptr);
+ ctx->SetLastTag(tag);
+ goto message_done;
+ }
+ ptr = UnknownFieldParse(
+ tag,
+ _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(),
+ ptr, ctx);
+ CHK_(ptr != nullptr);
+ } // while
+message_done:
+ return ptr;
+failure:
+ ptr = nullptr;
+ goto message_done;
+#undef CHK_
+}
+
+uint8_t* packet::_InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const {
+ // @@protoc_insertion_point(serialize_to_array_start:proto.packet)
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ // .proto.auth auth_packet = 1;
+ if (_internal_has_auth_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 1, _Internal::auth_packet(this), target, stream);
+ }
+
+ // .proto.init init_packet = 2;
+ if (_internal_has_init_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 2, _Internal::init_packet(this), target, stream);
+ }
+
+ // .proto.move move_packet = 3;
+ if (_internal_has_move_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 3, _Internal::move_packet(this), target, stream);
+ }
+
+ // .proto.player player_packet = 4;
+ if (_internal_has_player_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 4, _Internal::player_packet(this), target, stream);
+ }
+
+ // .proto.remove_player remove_player_packet = 5;
+ if (_internal_has_remove_player_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 5, _Internal::remove_player_packet(this), target, stream);
+ }
+
+ // .proto.say say_packet = 6;
+ if (_internal_has_say_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 6, _Internal::say_packet(this), target, stream);
+ }
+
+ // .proto.hear_player hear_player_packet = 7;
+ if (_internal_has_hear_player_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 7, _Internal::hear_player_packet(this), target, stream);
+ }
+
+ // .proto.request_chunk request_chunk_packet = 8;
+ if (_internal_has_request_chunk_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 8, _Internal::request_chunk_packet(this), target, stream);
+ }
+
+ // .proto.chunk chunk_packet = 9;
+ if (_internal_has_chunk_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 9, _Internal::chunk_packet(this), target, stream);
+ }
+
+ // .proto.remove_chunk remove_chunk_packet = 10;
+ if (_internal_has_remove_chunk_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 10, _Internal::remove_chunk_packet(this), target, stream);
+ }
+
+ // .proto.add_block add_block_packet = 11;
+ if (_internal_has_add_block_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 11, _Internal::add_block_packet(this), target, stream);
+ }
+
+ // .proto.remove_block remove_block_packet = 12;
+ if (_internal_has_remove_block_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 12, _Internal::remove_block_packet(this), target, stream);
+ }
+
+ // .proto.server_message server_message_packet = 13;
+ if (_internal_has_server_message_packet()) {
+ target = stream->EnsureSpace(target);
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::
+ InternalWriteMessage(
+ 13, _Internal::server_message_packet(this), target, stream);
+ }
+
+ if (PROTOBUF_PREDICT_FALSE(_internal_metadata_.have_unknown_fields())) {
+ target = ::PROTOBUF_NAMESPACE_ID::internal::WireFormat::InternalSerializeUnknownFieldsToArray(
+ _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance), target, stream);
+ }
+ // @@protoc_insertion_point(serialize_to_array_end:proto.packet)
+ return target;
+}
+
+size_t packet::ByteSizeLong() const {
+// @@protoc_insertion_point(message_byte_size_start:proto.packet)
+ size_t total_size = 0;
+
+ uint32_t cached_has_bits = 0;
+ // Prevent compiler warnings about cached_has_bits being unused
+ (void) cached_has_bits;
+
+ switch (contents_case()) {
+ // .proto.auth auth_packet = 1;
+ case kAuthPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.auth_packet_);
+ break;
+ }
+ // .proto.init init_packet = 2;
+ case kInitPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.init_packet_);
+ break;
+ }
+ // .proto.move move_packet = 3;
+ case kMovePacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.move_packet_);
+ break;
+ }
+ // .proto.player player_packet = 4;
+ case kPlayerPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.player_packet_);
+ break;
+ }
+ // .proto.remove_player remove_player_packet = 5;
+ case kRemovePlayerPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.remove_player_packet_);
+ break;
+ }
+ // .proto.say say_packet = 6;
+ case kSayPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.say_packet_);
+ break;
+ }
+ // .proto.hear_player hear_player_packet = 7;
+ case kHearPlayerPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.hear_player_packet_);
+ break;
+ }
+ // .proto.request_chunk request_chunk_packet = 8;
+ case kRequestChunkPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.request_chunk_packet_);
+ break;
+ }
+ // .proto.chunk chunk_packet = 9;
+ case kChunkPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.chunk_packet_);
+ break;
+ }
+ // .proto.remove_chunk remove_chunk_packet = 10;
+ case kRemoveChunkPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.remove_chunk_packet_);
+ break;
+ }
+ // .proto.add_block add_block_packet = 11;
+ case kAddBlockPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.add_block_packet_);
+ break;
+ }
+ // .proto.remove_block remove_block_packet = 12;
+ case kRemoveBlockPacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.remove_block_packet_);
+ break;
+ }
+ // .proto.server_message server_message_packet = 13;
+ case kServerMessagePacket: {
+ total_size += 1 +
+ ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::MessageSize(
+ *contents_.server_message_packet_);
+ break;
+ }
+ case CONTENTS_NOT_SET: {
+ break;
+ }
+ }
+ return MaybeComputeUnknownFieldsSize(total_size, &_cached_size_);
+}
+
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData packet::_class_data_ = {
+ ::PROTOBUF_NAMESPACE_ID::Message::CopyWithSizeCheck,
+ packet::MergeImpl
+};
+const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*packet::GetClassData() const { return &_class_data_; }
+
+void packet::MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to,
+ const ::PROTOBUF_NAMESPACE_ID::Message& from) {
+ static_cast<packet *>(to)->MergeFrom(
+ static_cast<const packet &>(from));
+}
+
+
+void packet::MergeFrom(const packet& from) {
+// @@protoc_insertion_point(class_specific_merge_from_start:proto.packet)
+ GOOGLE_DCHECK_NE(&from, this);
+ uint32_t cached_has_bits = 0;
+ (void) cached_has_bits;
+
+ switch (from.contents_case()) {
+ case kAuthPacket: {
+ _internal_mutable_auth_packet()->::proto::auth::MergeFrom(from._internal_auth_packet());
+ break;
+ }
+ case kInitPacket: {
+ _internal_mutable_init_packet()->::proto::init::MergeFrom(from._internal_init_packet());
+ break;
+ }
+ case kMovePacket: {
+ _internal_mutable_move_packet()->::proto::move::MergeFrom(from._internal_move_packet());
+ break;
+ }
+ case kPlayerPacket: {
+ _internal_mutable_player_packet()->::proto::player::MergeFrom(from._internal_player_packet());
+ break;
+ }
+ case kRemovePlayerPacket: {
+ _internal_mutable_remove_player_packet()->::proto::remove_player::MergeFrom(from._internal_remove_player_packet());
+ break;
+ }
+ case kSayPacket: {
+ _internal_mutable_say_packet()->::proto::say::MergeFrom(from._internal_say_packet());
+ break;
+ }
+ case kHearPlayerPacket: {
+ _internal_mutable_hear_player_packet()->::proto::hear_player::MergeFrom(from._internal_hear_player_packet());
+ break;
+ }
+ case kRequestChunkPacket: {
+ _internal_mutable_request_chunk_packet()->::proto::request_chunk::MergeFrom(from._internal_request_chunk_packet());
+ break;
+ }
+ case kChunkPacket: {
+ _internal_mutable_chunk_packet()->::proto::chunk::MergeFrom(from._internal_chunk_packet());
+ break;
+ }
+ case kRemoveChunkPacket: {
+ _internal_mutable_remove_chunk_packet()->::proto::remove_chunk::MergeFrom(from._internal_remove_chunk_packet());
+ break;
+ }
+ case kAddBlockPacket: {
+ _internal_mutable_add_block_packet()->::proto::add_block::MergeFrom(from._internal_add_block_packet());
+ break;
+ }
+ case kRemoveBlockPacket: {
+ _internal_mutable_remove_block_packet()->::proto::remove_block::MergeFrom(from._internal_remove_block_packet());
+ break;
+ }
+ case kServerMessagePacket: {
+ _internal_mutable_server_message_packet()->::proto::server_message::MergeFrom(from._internal_server_message_packet());
+ break;
+ }
+ case CONTENTS_NOT_SET: {
+ break;
+ }
+ }
+ _internal_metadata_.MergeFrom<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(from._internal_metadata_);
+}
+
+void packet::CopyFrom(const packet& from) {
+// @@protoc_insertion_point(class_specific_copy_from_start:proto.packet)
+ if (&from == this) return;
+ Clear();
+ MergeFrom(from);
+}
+
+bool packet::IsInitialized() const {
+ return true;
+}
+
+void packet::InternalSwap(packet* other) {
+ using std::swap;
+ _internal_metadata_.InternalSwap(&other->_internal_metadata_);
+ swap(contents_, other->contents_);
+ swap(_oneof_case_[0], other->_oneof_case_[0]);
+}
+
+::PROTOBUF_NAMESPACE_ID::Metadata packet::GetMetadata() const {
+ return ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(
+ &descriptor_table_net_2eproto_getter, &descriptor_table_net_2eproto_once,
+ file_level_metadata_net_2eproto[17]);
+}
+
+// @@protoc_insertion_point(namespace_scope)
+} // namespace proto
+PROTOBUF_NAMESPACE_OPEN
+template<> PROTOBUF_NOINLINE ::proto::angles* Arena::CreateMaybeMessage< ::proto::angles >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::angles >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::coords* Arena::CreateMaybeMessage< ::proto::coords >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::coords >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::vec3* Arena::CreateMaybeMessage< ::proto::vec3 >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::vec3 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::ivec3* Arena::CreateMaybeMessage< ::proto::ivec3 >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::ivec3 >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::player* Arena::CreateMaybeMessage< ::proto::player >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::player >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::auth* Arena::CreateMaybeMessage< ::proto::auth >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::auth >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::init* Arena::CreateMaybeMessage< ::proto::init >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::init >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::move* Arena::CreateMaybeMessage< ::proto::move >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::move >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::remove_player* Arena::CreateMaybeMessage< ::proto::remove_player >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::remove_player >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::say* Arena::CreateMaybeMessage< ::proto::say >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::say >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::hear_player* Arena::CreateMaybeMessage< ::proto::hear_player >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::hear_player >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::request_chunk* Arena::CreateMaybeMessage< ::proto::request_chunk >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::request_chunk >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::remove_chunk* Arena::CreateMaybeMessage< ::proto::remove_chunk >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::remove_chunk >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::chunk* Arena::CreateMaybeMessage< ::proto::chunk >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::chunk >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::add_block* Arena::CreateMaybeMessage< ::proto::add_block >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::add_block >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::remove_block* Arena::CreateMaybeMessage< ::proto::remove_block >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::remove_block >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::server_message* Arena::CreateMaybeMessage< ::proto::server_message >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::server_message >(arena);
+}
+template<> PROTOBUF_NOINLINE ::proto::packet* Arena::CreateMaybeMessage< ::proto::packet >(Arena* arena) {
+ return Arena::CreateMessageInternal< ::proto::packet >(arena);
+}
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+#include <google/protobuf/port_undef.inc>
diff --git a/src/shared/net/lib/protobuf/net.pb.h b/src/shared/net/lib/protobuf/net.pb.h
new file mode 100644
index 0000000..9160072
--- /dev/null
+++ b/src/shared/net/lib/protobuf/net.pb.h
@@ -0,0 +1,6386 @@
+// Generated by the protocol buffer compiler. DO NOT EDIT!
+// source: net.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_net_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_net_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3019000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3019002 < 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 <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h> // IWYU pragma: export
+#include <google/protobuf/extension_set.h> // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_net_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+} // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_net_2eproto {
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[18]
+ PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+ static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+ static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+ static const uint32_t offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_net_2eproto;
+namespace proto {
+class add_block;
+struct add_blockDefaultTypeInternal;
+extern add_blockDefaultTypeInternal _add_block_default_instance_;
+class angles;
+struct anglesDefaultTypeInternal;
+extern anglesDefaultTypeInternal _angles_default_instance_;
+class auth;
+struct authDefaultTypeInternal;
+extern authDefaultTypeInternal _auth_default_instance_;
+class chunk;
+struct chunkDefaultTypeInternal;
+extern chunkDefaultTypeInternal _chunk_default_instance_;
+class coords;
+struct coordsDefaultTypeInternal;
+extern coordsDefaultTypeInternal _coords_default_instance_;
+class hear_player;
+struct hear_playerDefaultTypeInternal;
+extern hear_playerDefaultTypeInternal _hear_player_default_instance_;
+class init;
+struct initDefaultTypeInternal;
+extern initDefaultTypeInternal _init_default_instance_;
+class ivec3;
+struct ivec3DefaultTypeInternal;
+extern ivec3DefaultTypeInternal _ivec3_default_instance_;
+class move;
+struct moveDefaultTypeInternal;
+extern moveDefaultTypeInternal _move_default_instance_;
+class packet;
+struct packetDefaultTypeInternal;
+extern packetDefaultTypeInternal _packet_default_instance_;
+class player;
+struct playerDefaultTypeInternal;
+extern playerDefaultTypeInternal _player_default_instance_;
+class remove_block;
+struct remove_blockDefaultTypeInternal;
+extern remove_blockDefaultTypeInternal _remove_block_default_instance_;
+class remove_chunk;
+struct remove_chunkDefaultTypeInternal;
+extern remove_chunkDefaultTypeInternal _remove_chunk_default_instance_;
+class remove_player;
+struct remove_playerDefaultTypeInternal;
+extern remove_playerDefaultTypeInternal _remove_player_default_instance_;
+class request_chunk;
+struct request_chunkDefaultTypeInternal;
+extern request_chunkDefaultTypeInternal _request_chunk_default_instance_;
+class say;
+struct sayDefaultTypeInternal;
+extern sayDefaultTypeInternal _say_default_instance_;
+class server_message;
+struct server_messageDefaultTypeInternal;
+extern server_messageDefaultTypeInternal _server_message_default_instance_;
+class vec3;
+struct vec3DefaultTypeInternal;
+extern vec3DefaultTypeInternal _vec3_default_instance_;
+} // namespace proto
+PROTOBUF_NAMESPACE_OPEN
+template<> ::proto::add_block* Arena::CreateMaybeMessage<::proto::add_block>(Arena*);
+template<> ::proto::angles* Arena::CreateMaybeMessage<::proto::angles>(Arena*);
+template<> ::proto::auth* Arena::CreateMaybeMessage<::proto::auth>(Arena*);
+template<> ::proto::chunk* Arena::CreateMaybeMessage<::proto::chunk>(Arena*);
+template<> ::proto::coords* Arena::CreateMaybeMessage<::proto::coords>(Arena*);
+template<> ::proto::hear_player* Arena::CreateMaybeMessage<::proto::hear_player>(Arena*);
+template<> ::proto::init* Arena::CreateMaybeMessage<::proto::init>(Arena*);
+template<> ::proto::ivec3* Arena::CreateMaybeMessage<::proto::ivec3>(Arena*);
+template<> ::proto::move* Arena::CreateMaybeMessage<::proto::move>(Arena*);
+template<> ::proto::packet* Arena::CreateMaybeMessage<::proto::packet>(Arena*);
+template<> ::proto::player* Arena::CreateMaybeMessage<::proto::player>(Arena*);
+template<> ::proto::remove_block* Arena::CreateMaybeMessage<::proto::remove_block>(Arena*);
+template<> ::proto::remove_chunk* Arena::CreateMaybeMessage<::proto::remove_chunk>(Arena*);
+template<> ::proto::remove_player* Arena::CreateMaybeMessage<::proto::remove_player>(Arena*);
+template<> ::proto::request_chunk* Arena::CreateMaybeMessage<::proto::request_chunk>(Arena*);
+template<> ::proto::say* Arena::CreateMaybeMessage<::proto::say>(Arena*);
+template<> ::proto::server_message* Arena::CreateMaybeMessage<::proto::server_message>(Arena*);
+template<> ::proto::vec3* Arena::CreateMaybeMessage<::proto::vec3>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace proto {
+
+// ===================================================================
+
+class angles final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.angles) */ {
+ public:
+ inline angles() : angles(nullptr) {}
+ ~angles() override;
+ explicit constexpr angles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ angles(const angles& from);
+ angles(angles&& from) noexcept
+ : angles() {
+ *this = ::std::move(from);
+ }
+
+ inline angles& operator=(const angles& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline angles& operator=(angles&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const angles& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const angles* internal_default_instance() {
+ return reinterpret_cast<const angles*>(
+ &_angles_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 0;
+
+ friend void swap(angles& a, angles& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(angles* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(angles* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ angles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<angles>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const angles& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const angles& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(angles* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.angles";
+ }
+ protected:
+ explicit angles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kPitchFieldNumber = 1,
+ kYawFieldNumber = 2,
+ };
+ // float pitch = 1;
+ void clear_pitch();
+ float pitch() const;
+ void set_pitch(float value);
+ private:
+ float _internal_pitch() const;
+ void _internal_set_pitch(float value);
+ public:
+
+ // float yaw = 2;
+ void clear_yaw();
+ float yaw() const;
+ void set_yaw(float value);
+ private:
+ float _internal_yaw() const;
+ void _internal_set_yaw(float value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.angles)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ float pitch_;
+ float yaw_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class coords final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.coords) */ {
+ public:
+ inline coords() : coords(nullptr) {}
+ ~coords() override;
+ explicit constexpr coords(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ coords(const coords& from);
+ coords(coords&& from) noexcept
+ : coords() {
+ *this = ::std::move(from);
+ }
+
+ inline coords& operator=(const coords& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline coords& operator=(coords&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const coords& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const coords* internal_default_instance() {
+ return reinterpret_cast<const coords*>(
+ &_coords_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 1;
+
+ friend void swap(coords& a, coords& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(coords* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(coords* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ coords* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<coords>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const coords& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const coords& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(coords* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.coords";
+ }
+ protected:
+ explicit coords(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kXFieldNumber = 1,
+ kZFieldNumber = 2,
+ };
+ // int32 x = 1;
+ void clear_x();
+ int32_t x() const;
+ void set_x(int32_t value);
+ private:
+ int32_t _internal_x() const;
+ void _internal_set_x(int32_t value);
+ public:
+
+ // int32 z = 2;
+ void clear_z();
+ int32_t z() const;
+ void set_z(int32_t value);
+ private:
+ int32_t _internal_z() const;
+ void _internal_set_z(int32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.coords)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ int32_t x_;
+ int32_t z_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class vec3 final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.vec3) */ {
+ public:
+ inline vec3() : vec3(nullptr) {}
+ ~vec3() override;
+ explicit constexpr vec3(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ vec3(const vec3& from);
+ vec3(vec3&& from) noexcept
+ : vec3() {
+ *this = ::std::move(from);
+ }
+
+ inline vec3& operator=(const vec3& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline vec3& operator=(vec3&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const vec3& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const vec3* internal_default_instance() {
+ return reinterpret_cast<const vec3*>(
+ &_vec3_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 2;
+
+ friend void swap(vec3& a, vec3& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(vec3* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(vec3* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ vec3* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<vec3>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const vec3& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const vec3& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(vec3* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.vec3";
+ }
+ protected:
+ explicit vec3(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kXFieldNumber = 1,
+ kYFieldNumber = 2,
+ kZFieldNumber = 3,
+ };
+ // float x = 1;
+ void clear_x();
+ float x() const;
+ void set_x(float value);
+ private:
+ float _internal_x() const;
+ void _internal_set_x(float value);
+ public:
+
+ // float y = 2;
+ void clear_y();
+ float y() const;
+ void set_y(float value);
+ private:
+ float _internal_y() const;
+ void _internal_set_y(float value);
+ public:
+
+ // float z = 3;
+ void clear_z();
+ float z() const;
+ void set_z(float value);
+ private:
+ float _internal_z() const;
+ void _internal_set_z(float value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.vec3)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ float x_;
+ float y_;
+ float z_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ivec3 final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.ivec3) */ {
+ public:
+ inline ivec3() : ivec3(nullptr) {}
+ ~ivec3() override;
+ explicit constexpr ivec3(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ ivec3(const ivec3& from);
+ ivec3(ivec3&& from) noexcept
+ : ivec3() {
+ *this = ::std::move(from);
+ }
+
+ inline ivec3& operator=(const ivec3& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline ivec3& operator=(ivec3&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const ivec3& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const ivec3* internal_default_instance() {
+ return reinterpret_cast<const ivec3*>(
+ &_ivec3_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 3;
+
+ friend void swap(ivec3& a, ivec3& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(ivec3* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(ivec3* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ ivec3* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<ivec3>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const ivec3& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const ivec3& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(ivec3* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.ivec3";
+ }
+ protected:
+ explicit ivec3(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kXFieldNumber = 1,
+ kYFieldNumber = 2,
+ kZFieldNumber = 3,
+ };
+ // int32 x = 1;
+ void clear_x();
+ int32_t x() const;
+ void set_x(int32_t value);
+ private:
+ int32_t _internal_x() const;
+ void _internal_set_x(int32_t value);
+ public:
+
+ // int32 y = 2;
+ void clear_y();
+ int32_t y() const;
+ void set_y(int32_t value);
+ private:
+ int32_t _internal_y() const;
+ void _internal_set_y(int32_t value);
+ public:
+
+ // int32 z = 3;
+ void clear_z();
+ int32_t z() const;
+ void set_z(int32_t value);
+ private:
+ int32_t _internal_z() const;
+ void _internal_set_z(int32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.ivec3)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ int32_t x_;
+ int32_t y_;
+ int32_t z_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class player final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.player) */ {
+ public:
+ inline player() : player(nullptr) {}
+ ~player() override;
+ explicit constexpr player(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ player(const player& from);
+ player(player&& from) noexcept
+ : player() {
+ *this = ::std::move(from);
+ }
+
+ inline player& operator=(const player& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline player& operator=(player&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const player& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const player* internal_default_instance() {
+ return reinterpret_cast<const player*>(
+ &_player_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 4;
+
+ friend void swap(player& a, player& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(player* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(player* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ player* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<player>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const player& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const player& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(player* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.player";
+ }
+ protected:
+ explicit player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kChunkPosFieldNumber = 3,
+ kLocalPosFieldNumber = 4,
+ kViewanglesFieldNumber = 5,
+ kVelocityFieldNumber = 6,
+ kIndexFieldNumber = 1,
+ kCommandsFieldNumber = 2,
+ };
+ // .proto.coords chunk_pos = 3;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // .proto.vec3 local_pos = 4;
+ bool has_local_pos() const;
+ private:
+ bool _internal_has_local_pos() const;
+ public:
+ void clear_local_pos();
+ const ::proto::vec3& local_pos() const;
+ PROTOBUF_NODISCARD ::proto::vec3* release_local_pos();
+ ::proto::vec3* mutable_local_pos();
+ void set_allocated_local_pos(::proto::vec3* local_pos);
+ private:
+ const ::proto::vec3& _internal_local_pos() const;
+ ::proto::vec3* _internal_mutable_local_pos();
+ public:
+ void unsafe_arena_set_allocated_local_pos(
+ ::proto::vec3* local_pos);
+ ::proto::vec3* unsafe_arena_release_local_pos();
+
+ // .proto.angles viewangles = 5;
+ bool has_viewangles() const;
+ private:
+ bool _internal_has_viewangles() const;
+ public:
+ void clear_viewangles();
+ const ::proto::angles& viewangles() const;
+ PROTOBUF_NODISCARD ::proto::angles* release_viewangles();
+ ::proto::angles* mutable_viewangles();
+ void set_allocated_viewangles(::proto::angles* viewangles);
+ private:
+ const ::proto::angles& _internal_viewangles() const;
+ ::proto::angles* _internal_mutable_viewangles();
+ public:
+ void unsafe_arena_set_allocated_viewangles(
+ ::proto::angles* viewangles);
+ ::proto::angles* unsafe_arena_release_viewangles();
+
+ // .proto.vec3 velocity = 6;
+ bool has_velocity() const;
+ private:
+ bool _internal_has_velocity() const;
+ public:
+ void clear_velocity();
+ const ::proto::vec3& velocity() const;
+ PROTOBUF_NODISCARD ::proto::vec3* release_velocity();
+ ::proto::vec3* mutable_velocity();
+ void set_allocated_velocity(::proto::vec3* velocity);
+ private:
+ const ::proto::vec3& _internal_velocity() const;
+ ::proto::vec3* _internal_mutable_velocity();
+ public:
+ void unsafe_arena_set_allocated_velocity(
+ ::proto::vec3* velocity);
+ ::proto::vec3* unsafe_arena_release_velocity();
+
+ // uint32 index = 1;
+ void clear_index();
+ uint32_t index() const;
+ void set_index(uint32_t value);
+ private:
+ uint32_t _internal_index() const;
+ void _internal_set_index(uint32_t value);
+ public:
+
+ // uint32 commands = 2;
+ void clear_commands();
+ uint32_t commands() const;
+ void set_commands(uint32_t value);
+ private:
+ uint32_t _internal_commands() const;
+ void _internal_set_commands(uint32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.player)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::coords* chunk_pos_;
+ ::proto::vec3* local_pos_;
+ ::proto::angles* viewangles_;
+ ::proto::vec3* velocity_;
+ uint32_t index_;
+ uint32_t commands_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class auth final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.auth) */ {
+ public:
+ inline auth() : auth(nullptr) {}
+ ~auth() override;
+ explicit constexpr auth(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ auth(const auth& from);
+ auth(auth&& from) noexcept
+ : auth() {
+ *this = ::std::move(from);
+ }
+
+ inline auth& operator=(const auth& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline auth& operator=(auth&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const auth& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const auth* internal_default_instance() {
+ return reinterpret_cast<const auth*>(
+ &_auth_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 5;
+
+ friend void swap(auth& a, auth& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(auth* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(auth* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ auth* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<auth>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const auth& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const auth& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(auth* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.auth";
+ }
+ protected:
+ explicit auth(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kUsernameFieldNumber = 1,
+ kPasswordFieldNumber = 2,
+ };
+ // string username = 1;
+ void clear_username();
+ const std::string& username() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_username(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_username();
+ PROTOBUF_NODISCARD std::string* release_username();
+ void set_allocated_username(std::string* username);
+ private:
+ const std::string& _internal_username() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_username(const std::string& value);
+ std::string* _internal_mutable_username();
+ public:
+
+ // string password = 2;
+ void clear_password();
+ const std::string& password() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_password(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_password();
+ PROTOBUF_NODISCARD std::string* release_password();
+ void set_allocated_password(std::string* password);
+ private:
+ const std::string& _internal_password() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_password(const std::string& value);
+ std::string* _internal_mutable_password();
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.auth)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr username_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr password_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class init final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.init) */ {
+ public:
+ inline init() : init(nullptr) {}
+ ~init() override;
+ explicit constexpr init(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ init(const init& from);
+ init(init&& from) noexcept
+ : init() {
+ *this = ::std::move(from);
+ }
+
+ inline init& operator=(const init& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline init& operator=(init&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const init& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const init* internal_default_instance() {
+ return reinterpret_cast<const init*>(
+ &_init_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 6;
+
+ friend void swap(init& a, init& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(init* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(init* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ init* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<init>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const init& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const init& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(init* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.init";
+ }
+ protected:
+ explicit init(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kLocalplayerFieldNumber = 3,
+ kSeedFieldNumber = 1,
+ kDrawDistanceFieldNumber = 2,
+ };
+ // .proto.player localplayer = 3;
+ bool has_localplayer() const;
+ private:
+ bool _internal_has_localplayer() const;
+ public:
+ void clear_localplayer();
+ const ::proto::player& localplayer() const;
+ PROTOBUF_NODISCARD ::proto::player* release_localplayer();
+ ::proto::player* mutable_localplayer();
+ void set_allocated_localplayer(::proto::player* localplayer);
+ private:
+ const ::proto::player& _internal_localplayer() const;
+ ::proto::player* _internal_mutable_localplayer();
+ public:
+ void unsafe_arena_set_allocated_localplayer(
+ ::proto::player* localplayer);
+ ::proto::player* unsafe_arena_release_localplayer();
+
+ // uint64 seed = 1;
+ void clear_seed();
+ uint64_t seed() const;
+ void set_seed(uint64_t value);
+ private:
+ uint64_t _internal_seed() const;
+ void _internal_set_seed(uint64_t value);
+ public:
+
+ // int32 draw_distance = 2;
+ void clear_draw_distance();
+ int32_t draw_distance() const;
+ void set_draw_distance(int32_t value);
+ private:
+ int32_t _internal_draw_distance() const;
+ void _internal_set_draw_distance(int32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.init)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::player* localplayer_;
+ uint64_t seed_;
+ int32_t draw_distance_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class move final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.move) */ {
+ public:
+ inline move() : move(nullptr) {}
+ ~move() override;
+ explicit constexpr move(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ move(const move& from);
+ move(move&& from) noexcept
+ : move() {
+ *this = ::std::move(from);
+ }
+
+ inline move& operator=(const move& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline move& operator=(move&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const move& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const move* internal_default_instance() {
+ return reinterpret_cast<const move*>(
+ &_move_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 7;
+
+ friend void swap(move& a, move& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(move* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(move* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ move* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<move>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const move& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const move& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(move* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.move";
+ }
+ protected:
+ explicit move(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kViewanglesFieldNumber = 2,
+ kCommandsFieldNumber = 1,
+ };
+ // .proto.angles viewangles = 2;
+ bool has_viewangles() const;
+ private:
+ bool _internal_has_viewangles() const;
+ public:
+ void clear_viewangles();
+ const ::proto::angles& viewangles() const;
+ PROTOBUF_NODISCARD ::proto::angles* release_viewangles();
+ ::proto::angles* mutable_viewangles();
+ void set_allocated_viewangles(::proto::angles* viewangles);
+ private:
+ const ::proto::angles& _internal_viewangles() const;
+ ::proto::angles* _internal_mutable_viewangles();
+ public:
+ void unsafe_arena_set_allocated_viewangles(
+ ::proto::angles* viewangles);
+ ::proto::angles* unsafe_arena_release_viewangles();
+
+ // uint32 commands = 1;
+ void clear_commands();
+ uint32_t commands() const;
+ void set_commands(uint32_t value);
+ private:
+ uint32_t _internal_commands() const;
+ void _internal_set_commands(uint32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.move)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::angles* viewangles_;
+ uint32_t commands_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class remove_player final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.remove_player) */ {
+ public:
+ inline remove_player() : remove_player(nullptr) {}
+ ~remove_player() override;
+ explicit constexpr remove_player(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ remove_player(const remove_player& from);
+ remove_player(remove_player&& from) noexcept
+ : remove_player() {
+ *this = ::std::move(from);
+ }
+
+ inline remove_player& operator=(const remove_player& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline remove_player& operator=(remove_player&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const remove_player& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const remove_player* internal_default_instance() {
+ return reinterpret_cast<const remove_player*>(
+ &_remove_player_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 8;
+
+ friend void swap(remove_player& a, remove_player& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(remove_player* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(remove_player* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ remove_player* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<remove_player>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const remove_player& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const remove_player& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(remove_player* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.remove_player";
+ }
+ protected:
+ explicit remove_player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kIndexFieldNumber = 1,
+ };
+ // uint32 index = 1;
+ void clear_index();
+ uint32_t index() const;
+ void set_index(uint32_t value);
+ private:
+ uint32_t _internal_index() const;
+ void _internal_set_index(uint32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.remove_player)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ uint32_t index_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class say final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.say) */ {
+ public:
+ inline say() : say(nullptr) {}
+ ~say() override;
+ explicit constexpr say(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ say(const say& from);
+ say(say&& from) noexcept
+ : say() {
+ *this = ::std::move(from);
+ }
+
+ inline say& operator=(const say& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline say& operator=(say&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const say& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const say* internal_default_instance() {
+ return reinterpret_cast<const say*>(
+ &_say_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 9;
+
+ friend void swap(say& a, say& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(say* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(say* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ say* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<say>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const say& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const say& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(say* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.say";
+ }
+ protected:
+ explicit say(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTextFieldNumber = 1,
+ };
+ // string text = 1;
+ void clear_text();
+ const std::string& text() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_text(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_text();
+ PROTOBUF_NODISCARD std::string* release_text();
+ void set_allocated_text(std::string* text);
+ private:
+ const std::string& _internal_text() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+ std::string* _internal_mutable_text();
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.say)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class hear_player final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.hear_player) */ {
+ public:
+ inline hear_player() : hear_player(nullptr) {}
+ ~hear_player() override;
+ explicit constexpr hear_player(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ hear_player(const hear_player& from);
+ hear_player(hear_player&& from) noexcept
+ : hear_player() {
+ *this = ::std::move(from);
+ }
+
+ inline hear_player& operator=(const hear_player& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline hear_player& operator=(hear_player&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const hear_player& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const hear_player* internal_default_instance() {
+ return reinterpret_cast<const hear_player*>(
+ &_hear_player_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 10;
+
+ friend void swap(hear_player& a, hear_player& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(hear_player* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(hear_player* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ hear_player* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<hear_player>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const hear_player& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const hear_player& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(hear_player* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.hear_player";
+ }
+ protected:
+ explicit hear_player(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kTextFieldNumber = 2,
+ kIndexFieldNumber = 1,
+ };
+ // string text = 2;
+ void clear_text();
+ const std::string& text() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_text(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_text();
+ PROTOBUF_NODISCARD std::string* release_text();
+ void set_allocated_text(std::string* text);
+ private:
+ const std::string& _internal_text() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_text(const std::string& value);
+ std::string* _internal_mutable_text();
+ public:
+
+ // uint32 index = 1;
+ void clear_index();
+ uint32_t index() const;
+ void set_index(uint32_t value);
+ private:
+ uint32_t _internal_index() const;
+ void _internal_set_index(uint32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.hear_player)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr text_;
+ uint32_t index_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class request_chunk final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.request_chunk) */ {
+ public:
+ inline request_chunk() : request_chunk(nullptr) {}
+ ~request_chunk() override;
+ explicit constexpr request_chunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ request_chunk(const request_chunk& from);
+ request_chunk(request_chunk&& from) noexcept
+ : request_chunk() {
+ *this = ::std::move(from);
+ }
+
+ inline request_chunk& operator=(const request_chunk& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline request_chunk& operator=(request_chunk&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const request_chunk& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const request_chunk* internal_default_instance() {
+ return reinterpret_cast<const request_chunk*>(
+ &_request_chunk_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 11;
+
+ friend void swap(request_chunk& a, request_chunk& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(request_chunk* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(request_chunk* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ request_chunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<request_chunk>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const request_chunk& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const request_chunk& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(request_chunk* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.request_chunk";
+ }
+ protected:
+ explicit request_chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kChunkPosFieldNumber = 1,
+ };
+ // .proto.coords chunk_pos = 1;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // @@protoc_insertion_point(class_scope:proto.request_chunk)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::coords* chunk_pos_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class remove_chunk final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.remove_chunk) */ {
+ public:
+ inline remove_chunk() : remove_chunk(nullptr) {}
+ ~remove_chunk() override;
+ explicit constexpr remove_chunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ remove_chunk(const remove_chunk& from);
+ remove_chunk(remove_chunk&& from) noexcept
+ : remove_chunk() {
+ *this = ::std::move(from);
+ }
+
+ inline remove_chunk& operator=(const remove_chunk& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline remove_chunk& operator=(remove_chunk&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const remove_chunk& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const remove_chunk* internal_default_instance() {
+ return reinterpret_cast<const remove_chunk*>(
+ &_remove_chunk_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 12;
+
+ friend void swap(remove_chunk& a, remove_chunk& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(remove_chunk* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(remove_chunk* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ remove_chunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<remove_chunk>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const remove_chunk& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const remove_chunk& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(remove_chunk* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.remove_chunk";
+ }
+ protected:
+ explicit remove_chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kChunkPosFieldNumber = 1,
+ };
+ // .proto.coords chunk_pos = 1;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // @@protoc_insertion_point(class_scope:proto.remove_chunk)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::coords* chunk_pos_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class chunk final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.chunk) */ {
+ public:
+ inline chunk() : chunk(nullptr) {}
+ ~chunk() override;
+ explicit constexpr chunk(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ chunk(const chunk& from);
+ chunk(chunk&& from) noexcept
+ : chunk() {
+ *this = ::std::move(from);
+ }
+
+ inline chunk& operator=(const chunk& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline chunk& operator=(chunk&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const chunk& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const chunk* internal_default_instance() {
+ return reinterpret_cast<const chunk*>(
+ &_chunk_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 13;
+
+ friend void swap(chunk& a, chunk& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(chunk* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(chunk* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ chunk* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<chunk>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const chunk& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const chunk& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(chunk* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.chunk";
+ }
+ protected:
+ explicit chunk(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kBlocksFieldNumber = 2,
+ kChunkPosFieldNumber = 1,
+ };
+ // repeated uint32 blocks = 2 [packed = true];
+ int blocks_size() const;
+ private:
+ int _internal_blocks_size() const;
+ public:
+ void clear_blocks();
+ private:
+ uint32_t _internal_blocks(int index) const;
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ _internal_blocks() const;
+ void _internal_add_blocks(uint32_t value);
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ _internal_mutable_blocks();
+ public:
+ uint32_t blocks(int index) const;
+ void set_blocks(int index, uint32_t value);
+ void add_blocks(uint32_t value);
+ const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+ blocks() const;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+ mutable_blocks();
+
+ // .proto.coords chunk_pos = 1;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // @@protoc_insertion_point(class_scope:proto.chunk)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t > blocks_;
+ mutable std::atomic<int> _blocks_cached_byte_size_;
+ ::proto::coords* chunk_pos_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class add_block final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.add_block) */ {
+ public:
+ inline add_block() : add_block(nullptr) {}
+ ~add_block() override;
+ explicit constexpr add_block(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ add_block(const add_block& from);
+ add_block(add_block&& from) noexcept
+ : add_block() {
+ *this = ::std::move(from);
+ }
+
+ inline add_block& operator=(const add_block& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline add_block& operator=(add_block&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const add_block& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const add_block* internal_default_instance() {
+ return reinterpret_cast<const add_block*>(
+ &_add_block_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 14;
+
+ friend void swap(add_block& a, add_block& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(add_block* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(add_block* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ add_block* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<add_block>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const add_block& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const add_block& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(add_block* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.add_block";
+ }
+ protected:
+ explicit add_block(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kChunkPosFieldNumber = 1,
+ kBlockPosFieldNumber = 2,
+ kBlockFieldNumber = 3,
+ };
+ // .proto.coords chunk_pos = 1;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // .proto.ivec3 block_pos = 2;
+ bool has_block_pos() const;
+ private:
+ bool _internal_has_block_pos() const;
+ public:
+ void clear_block_pos();
+ const ::proto::ivec3& block_pos() const;
+ PROTOBUF_NODISCARD ::proto::ivec3* release_block_pos();
+ ::proto::ivec3* mutable_block_pos();
+ void set_allocated_block_pos(::proto::ivec3* block_pos);
+ private:
+ const ::proto::ivec3& _internal_block_pos() const;
+ ::proto::ivec3* _internal_mutable_block_pos();
+ public:
+ void unsafe_arena_set_allocated_block_pos(
+ ::proto::ivec3* block_pos);
+ ::proto::ivec3* unsafe_arena_release_block_pos();
+
+ // uint32 block = 3;
+ void clear_block();
+ uint32_t block() const;
+ void set_block(uint32_t value);
+ private:
+ uint32_t _internal_block() const;
+ void _internal_set_block(uint32_t value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.add_block)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::coords* chunk_pos_;
+ ::proto::ivec3* block_pos_;
+ uint32_t block_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class remove_block final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.remove_block) */ {
+ public:
+ inline remove_block() : remove_block(nullptr) {}
+ ~remove_block() override;
+ explicit constexpr remove_block(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ remove_block(const remove_block& from);
+ remove_block(remove_block&& from) noexcept
+ : remove_block() {
+ *this = ::std::move(from);
+ }
+
+ inline remove_block& operator=(const remove_block& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline remove_block& operator=(remove_block&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const remove_block& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const remove_block* internal_default_instance() {
+ return reinterpret_cast<const remove_block*>(
+ &_remove_block_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 15;
+
+ friend void swap(remove_block& a, remove_block& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(remove_block* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(remove_block* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ remove_block* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<remove_block>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const remove_block& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const remove_block& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(remove_block* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.remove_block";
+ }
+ protected:
+ explicit remove_block(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kChunkPosFieldNumber = 1,
+ kBlockPosFieldNumber = 2,
+ };
+ // .proto.coords chunk_pos = 1;
+ bool has_chunk_pos() const;
+ private:
+ bool _internal_has_chunk_pos() const;
+ public:
+ void clear_chunk_pos();
+ const ::proto::coords& chunk_pos() const;
+ PROTOBUF_NODISCARD ::proto::coords* release_chunk_pos();
+ ::proto::coords* mutable_chunk_pos();
+ void set_allocated_chunk_pos(::proto::coords* chunk_pos);
+ private:
+ const ::proto::coords& _internal_chunk_pos() const;
+ ::proto::coords* _internal_mutable_chunk_pos();
+ public:
+ void unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos);
+ ::proto::coords* unsafe_arena_release_chunk_pos();
+
+ // .proto.ivec3 block_pos = 2;
+ bool has_block_pos() const;
+ private:
+ bool _internal_has_block_pos() const;
+ public:
+ void clear_block_pos();
+ const ::proto::ivec3& block_pos() const;
+ PROTOBUF_NODISCARD ::proto::ivec3* release_block_pos();
+ ::proto::ivec3* mutable_block_pos();
+ void set_allocated_block_pos(::proto::ivec3* block_pos);
+ private:
+ const ::proto::ivec3& _internal_block_pos() const;
+ ::proto::ivec3* _internal_mutable_block_pos();
+ public:
+ void unsafe_arena_set_allocated_block_pos(
+ ::proto::ivec3* block_pos);
+ ::proto::ivec3* unsafe_arena_release_block_pos();
+
+ // @@protoc_insertion_point(class_scope:proto.remove_block)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::proto::coords* chunk_pos_;
+ ::proto::ivec3* block_pos_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class server_message final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.server_message) */ {
+ public:
+ inline server_message() : server_message(nullptr) {}
+ ~server_message() override;
+ explicit constexpr server_message(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ server_message(const server_message& from);
+ server_message(server_message&& from) noexcept
+ : server_message() {
+ *this = ::std::move(from);
+ }
+
+ inline server_message& operator=(const server_message& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline server_message& operator=(server_message&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const server_message& default_instance() {
+ return *internal_default_instance();
+ }
+ static inline const server_message* internal_default_instance() {
+ return reinterpret_cast<const server_message*>(
+ &_server_message_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 16;
+
+ friend void swap(server_message& a, server_message& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(server_message* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(server_message* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ server_message* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<server_message>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const server_message& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const server_message& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(server_message* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.server_message";
+ }
+ protected:
+ explicit server_message(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kMessageFieldNumber = 1,
+ kFatalFieldNumber = 2,
+ };
+ // string message = 1;
+ void clear_message();
+ const std::string& message() const;
+ template <typename ArgT0 = const std::string&, typename... ArgT>
+ void set_message(ArgT0&& arg0, ArgT... args);
+ std::string* mutable_message();
+ PROTOBUF_NODISCARD std::string* release_message();
+ void set_allocated_message(std::string* message);
+ private:
+ const std::string& _internal_message() const;
+ inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+ std::string* _internal_mutable_message();
+ public:
+
+ // bool fatal = 2;
+ void clear_fatal();
+ bool fatal() const;
+ void set_fatal(bool value);
+ private:
+ bool _internal_fatal() const;
+ void _internal_set_fatal(bool value);
+ public:
+
+ // @@protoc_insertion_point(class_scope:proto.server_message)
+ private:
+ class _Internal;
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+ bool fatal_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ friend struct ::TableStruct_net_2eproto;
+};
+// -------------------------------------------------------------------
+
+class packet final :
+ public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:proto.packet) */ {
+ public:
+ inline packet() : packet(nullptr) {}
+ ~packet() override;
+ explicit constexpr packet(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+ packet(const packet& from);
+ packet(packet&& from) noexcept
+ : packet() {
+ *this = ::std::move(from);
+ }
+
+ inline packet& operator=(const packet& from) {
+ CopyFrom(from);
+ return *this;
+ }
+ inline packet& operator=(packet&& from) noexcept {
+ if (this == &from) return *this;
+ if (GetOwningArena() == from.GetOwningArena()
+ #ifdef PROTOBUF_FORCE_COPY_IN_MOVE
+ && GetOwningArena() != nullptr
+ #endif // !PROTOBUF_FORCE_COPY_IN_MOVE
+ ) {
+ InternalSwap(&from);
+ } else {
+ CopyFrom(from);
+ }
+ return *this;
+ }
+
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+ return GetDescriptor();
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+ return default_instance().GetMetadata().descriptor;
+ }
+ static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+ return default_instance().GetMetadata().reflection;
+ }
+ static const packet& default_instance() {
+ return *internal_default_instance();
+ }
+ enum ContentsCase {
+ kAuthPacket = 1,
+ kInitPacket = 2,
+ kMovePacket = 3,
+ kPlayerPacket = 4,
+ kRemovePlayerPacket = 5,
+ kSayPacket = 6,
+ kHearPlayerPacket = 7,
+ kRequestChunkPacket = 8,
+ kChunkPacket = 9,
+ kRemoveChunkPacket = 10,
+ kAddBlockPacket = 11,
+ kRemoveBlockPacket = 12,
+ kServerMessagePacket = 13,
+ CONTENTS_NOT_SET = 0,
+ };
+
+ static inline const packet* internal_default_instance() {
+ return reinterpret_cast<const packet*>(
+ &_packet_default_instance_);
+ }
+ static constexpr int kIndexInFileMessages =
+ 17;
+
+ friend void swap(packet& a, packet& b) {
+ a.Swap(&b);
+ }
+ inline void Swap(packet* other) {
+ if (other == this) return;
+ #ifdef PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() != nullptr &&
+ GetOwningArena() == other->GetOwningArena()) {
+ #else // PROTOBUF_FORCE_COPY_IN_SWAP
+ if (GetOwningArena() == other->GetOwningArena()) {
+ #endif // !PROTOBUF_FORCE_COPY_IN_SWAP
+ InternalSwap(other);
+ } else {
+ ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+ }
+ }
+ void UnsafeArenaSwap(packet* other) {
+ if (other == this) return;
+ GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+ InternalSwap(other);
+ }
+
+ // implements Message ----------------------------------------------
+
+ packet* New(::PROTOBUF_NAMESPACE_ID::Arena* arena = nullptr) const final {
+ return CreateMaybeMessage<packet>(arena);
+ }
+ using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+ void CopyFrom(const packet& from);
+ using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+ void MergeFrom(const packet& from);
+ private:
+ static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message* to, const ::PROTOBUF_NAMESPACE_ID::Message& from);
+ public:
+ PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+ bool IsInitialized() const final;
+
+ size_t ByteSizeLong() const final;
+ const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+ uint8_t* _InternalSerialize(
+ uint8_t* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+ int GetCachedSize() const final { return _cached_size_.Get(); }
+
+ private:
+ void SharedCtor();
+ void SharedDtor();
+ void SetCachedSize(int size) const final;
+ void InternalSwap(packet* other);
+
+ private:
+ friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+ static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+ return "proto.packet";
+ }
+ protected:
+ explicit packet(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+ bool is_message_owned = false);
+ private:
+ static void ArenaDtor(void* object);
+ inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+ public:
+
+ static const ClassData _class_data_;
+ const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+ ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+ // nested types ----------------------------------------------------
+
+ // accessors -------------------------------------------------------
+
+ enum : int {
+ kAuthPacketFieldNumber = 1,
+ kInitPacketFieldNumber = 2,
+ kMovePacketFieldNumber = 3,
+ kPlayerPacketFieldNumber = 4,
+ kRemovePlayerPacketFieldNumber = 5,
+ kSayPacketFieldNumber = 6,
+ kHearPlayerPacketFieldNumber = 7,
+ kRequestChunkPacketFieldNumber = 8,
+ kChunkPacketFieldNumber = 9,
+ kRemoveChunkPacketFieldNumber = 10,
+ kAddBlockPacketFieldNumber = 11,
+ kRemoveBlockPacketFieldNumber = 12,
+ kServerMessagePacketFieldNumber = 13,
+ };
+ // .proto.auth auth_packet = 1;
+ bool has_auth_packet() const;
+ private:
+ bool _internal_has_auth_packet() const;
+ public:
+ void clear_auth_packet();
+ const ::proto::auth& auth_packet() const;
+ PROTOBUF_NODISCARD ::proto::auth* release_auth_packet();
+ ::proto::auth* mutable_auth_packet();
+ void set_allocated_auth_packet(::proto::auth* auth_packet);
+ private:
+ const ::proto::auth& _internal_auth_packet() const;
+ ::proto::auth* _internal_mutable_auth_packet();
+ public:
+ void unsafe_arena_set_allocated_auth_packet(
+ ::proto::auth* auth_packet);
+ ::proto::auth* unsafe_arena_release_auth_packet();
+
+ // .proto.init init_packet = 2;
+ bool has_init_packet() const;
+ private:
+ bool _internal_has_init_packet() const;
+ public:
+ void clear_init_packet();
+ const ::proto::init& init_packet() const;
+ PROTOBUF_NODISCARD ::proto::init* release_init_packet();
+ ::proto::init* mutable_init_packet();
+ void set_allocated_init_packet(::proto::init* init_packet);
+ private:
+ const ::proto::init& _internal_init_packet() const;
+ ::proto::init* _internal_mutable_init_packet();
+ public:
+ void unsafe_arena_set_allocated_init_packet(
+ ::proto::init* init_packet);
+ ::proto::init* unsafe_arena_release_init_packet();
+
+ // .proto.move move_packet = 3;
+ bool has_move_packet() const;
+ private:
+ bool _internal_has_move_packet() const;
+ public:
+ void clear_move_packet();
+ const ::proto::move& move_packet() const;
+ PROTOBUF_NODISCARD ::proto::move* release_move_packet();
+ ::proto::move* mutable_move_packet();
+ void set_allocated_move_packet(::proto::move* move_packet);
+ private:
+ const ::proto::move& _internal_move_packet() const;
+ ::proto::move* _internal_mutable_move_packet();
+ public:
+ void unsafe_arena_set_allocated_move_packet(
+ ::proto::move* move_packet);
+ ::proto::move* unsafe_arena_release_move_packet();
+
+ // .proto.player player_packet = 4;
+ bool has_player_packet() const;
+ private:
+ bool _internal_has_player_packet() const;
+ public:
+ void clear_player_packet();
+ const ::proto::player& player_packet() const;
+ PROTOBUF_NODISCARD ::proto::player* release_player_packet();
+ ::proto::player* mutable_player_packet();
+ void set_allocated_player_packet(::proto::player* player_packet);
+ private:
+ const ::proto::player& _internal_player_packet() const;
+ ::proto::player* _internal_mutable_player_packet();
+ public:
+ void unsafe_arena_set_allocated_player_packet(
+ ::proto::player* player_packet);
+ ::proto::player* unsafe_arena_release_player_packet();
+
+ // .proto.remove_player remove_player_packet = 5;
+ bool has_remove_player_packet() const;
+ private:
+ bool _internal_has_remove_player_packet() const;
+ public:
+ void clear_remove_player_packet();
+ const ::proto::remove_player& remove_player_packet() const;
+ PROTOBUF_NODISCARD ::proto::remove_player* release_remove_player_packet();
+ ::proto::remove_player* mutable_remove_player_packet();
+ void set_allocated_remove_player_packet(::proto::remove_player* remove_player_packet);
+ private:
+ const ::proto::remove_player& _internal_remove_player_packet() const;
+ ::proto::remove_player* _internal_mutable_remove_player_packet();
+ public:
+ void unsafe_arena_set_allocated_remove_player_packet(
+ ::proto::remove_player* remove_player_packet);
+ ::proto::remove_player* unsafe_arena_release_remove_player_packet();
+
+ // .proto.say say_packet = 6;
+ bool has_say_packet() const;
+ private:
+ bool _internal_has_say_packet() const;
+ public:
+ void clear_say_packet();
+ const ::proto::say& say_packet() const;
+ PROTOBUF_NODISCARD ::proto::say* release_say_packet();
+ ::proto::say* mutable_say_packet();
+ void set_allocated_say_packet(::proto::say* say_packet);
+ private:
+ const ::proto::say& _internal_say_packet() const;
+ ::proto::say* _internal_mutable_say_packet();
+ public:
+ void unsafe_arena_set_allocated_say_packet(
+ ::proto::say* say_packet);
+ ::proto::say* unsafe_arena_release_say_packet();
+
+ // .proto.hear_player hear_player_packet = 7;
+ bool has_hear_player_packet() const;
+ private:
+ bool _internal_has_hear_player_packet() const;
+ public:
+ void clear_hear_player_packet();
+ const ::proto::hear_player& hear_player_packet() const;
+ PROTOBUF_NODISCARD ::proto::hear_player* release_hear_player_packet();
+ ::proto::hear_player* mutable_hear_player_packet();
+ void set_allocated_hear_player_packet(::proto::hear_player* hear_player_packet);
+ private:
+ const ::proto::hear_player& _internal_hear_player_packet() const;
+ ::proto::hear_player* _internal_mutable_hear_player_packet();
+ public:
+ void unsafe_arena_set_allocated_hear_player_packet(
+ ::proto::hear_player* hear_player_packet);
+ ::proto::hear_player* unsafe_arena_release_hear_player_packet();
+
+ // .proto.request_chunk request_chunk_packet = 8;
+ bool has_request_chunk_packet() const;
+ private:
+ bool _internal_has_request_chunk_packet() const;
+ public:
+ void clear_request_chunk_packet();
+ const ::proto::request_chunk& request_chunk_packet() const;
+ PROTOBUF_NODISCARD ::proto::request_chunk* release_request_chunk_packet();
+ ::proto::request_chunk* mutable_request_chunk_packet();
+ void set_allocated_request_chunk_packet(::proto::request_chunk* request_chunk_packet);
+ private:
+ const ::proto::request_chunk& _internal_request_chunk_packet() const;
+ ::proto::request_chunk* _internal_mutable_request_chunk_packet();
+ public:
+ void unsafe_arena_set_allocated_request_chunk_packet(
+ ::proto::request_chunk* request_chunk_packet);
+ ::proto::request_chunk* unsafe_arena_release_request_chunk_packet();
+
+ // .proto.chunk chunk_packet = 9;
+ bool has_chunk_packet() const;
+ private:
+ bool _internal_has_chunk_packet() const;
+ public:
+ void clear_chunk_packet();
+ const ::proto::chunk& chunk_packet() const;
+ PROTOBUF_NODISCARD ::proto::chunk* release_chunk_packet();
+ ::proto::chunk* mutable_chunk_packet();
+ void set_allocated_chunk_packet(::proto::chunk* chunk_packet);
+ private:
+ const ::proto::chunk& _internal_chunk_packet() const;
+ ::proto::chunk* _internal_mutable_chunk_packet();
+ public:
+ void unsafe_arena_set_allocated_chunk_packet(
+ ::proto::chunk* chunk_packet);
+ ::proto::chunk* unsafe_arena_release_chunk_packet();
+
+ // .proto.remove_chunk remove_chunk_packet = 10;
+ bool has_remove_chunk_packet() const;
+ private:
+ bool _internal_has_remove_chunk_packet() const;
+ public:
+ void clear_remove_chunk_packet();
+ const ::proto::remove_chunk& remove_chunk_packet() const;
+ PROTOBUF_NODISCARD ::proto::remove_chunk* release_remove_chunk_packet();
+ ::proto::remove_chunk* mutable_remove_chunk_packet();
+ void set_allocated_remove_chunk_packet(::proto::remove_chunk* remove_chunk_packet);
+ private:
+ const ::proto::remove_chunk& _internal_remove_chunk_packet() const;
+ ::proto::remove_chunk* _internal_mutable_remove_chunk_packet();
+ public:
+ void unsafe_arena_set_allocated_remove_chunk_packet(
+ ::proto::remove_chunk* remove_chunk_packet);
+ ::proto::remove_chunk* unsafe_arena_release_remove_chunk_packet();
+
+ // .proto.add_block add_block_packet = 11;
+ bool has_add_block_packet() const;
+ private:
+ bool _internal_has_add_block_packet() const;
+ public:
+ void clear_add_block_packet();
+ const ::proto::add_block& add_block_packet() const;
+ PROTOBUF_NODISCARD ::proto::add_block* release_add_block_packet();
+ ::proto::add_block* mutable_add_block_packet();
+ void set_allocated_add_block_packet(::proto::add_block* add_block_packet);
+ private:
+ const ::proto::add_block& _internal_add_block_packet() const;
+ ::proto::add_block* _internal_mutable_add_block_packet();
+ public:
+ void unsafe_arena_set_allocated_add_block_packet(
+ ::proto::add_block* add_block_packet);
+ ::proto::add_block* unsafe_arena_release_add_block_packet();
+
+ // .proto.remove_block remove_block_packet = 12;
+ bool has_remove_block_packet() const;
+ private:
+ bool _internal_has_remove_block_packet() const;
+ public:
+ void clear_remove_block_packet();
+ const ::proto::remove_block& remove_block_packet() const;
+ PROTOBUF_NODISCARD ::proto::remove_block* release_remove_block_packet();
+ ::proto::remove_block* mutable_remove_block_packet();
+ void set_allocated_remove_block_packet(::proto::remove_block* remove_block_packet);
+ private:
+ const ::proto::remove_block& _internal_remove_block_packet() const;
+ ::proto::remove_block* _internal_mutable_remove_block_packet();
+ public:
+ void unsafe_arena_set_allocated_remove_block_packet(
+ ::proto::remove_block* remove_block_packet);
+ ::proto::remove_block* unsafe_arena_release_remove_block_packet();
+
+ // .proto.server_message server_message_packet = 13;
+ bool has_server_message_packet() const;
+ private:
+ bool _internal_has_server_message_packet() const;
+ public:
+ void clear_server_message_packet();
+ const ::proto::server_message& server_message_packet() const;
+ PROTOBUF_NODISCARD ::proto::server_message* release_server_message_packet();
+ ::proto::server_message* mutable_server_message_packet();
+ void set_allocated_server_message_packet(::proto::server_message* server_message_packet);
+ private:
+ const ::proto::server_message& _internal_server_message_packet() const;
+ ::proto::server_message* _internal_mutable_server_message_packet();
+ public:
+ void unsafe_arena_set_allocated_server_message_packet(
+ ::proto::server_message* server_message_packet);
+ ::proto::server_message* unsafe_arena_release_server_message_packet();
+
+ void clear_contents();
+ ContentsCase contents_case() const;
+ // @@protoc_insertion_point(class_scope:proto.packet)
+ private:
+ class _Internal;
+ void set_has_auth_packet();
+ void set_has_init_packet();
+ void set_has_move_packet();
+ void set_has_player_packet();
+ void set_has_remove_player_packet();
+ void set_has_say_packet();
+ void set_has_hear_player_packet();
+ void set_has_request_chunk_packet();
+ void set_has_chunk_packet();
+ void set_has_remove_chunk_packet();
+ void set_has_add_block_packet();
+ void set_has_remove_block_packet();
+ void set_has_server_message_packet();
+
+ inline bool has_contents() const;
+ inline void clear_has_contents();
+
+ template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+ typedef void InternalArenaConstructable_;
+ typedef void DestructorSkippable_;
+ union ContentsUnion {
+ constexpr ContentsUnion() : _constinit_{} {}
+ ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+ ::proto::auth* auth_packet_;
+ ::proto::init* init_packet_;
+ ::proto::move* move_packet_;
+ ::proto::player* player_packet_;
+ ::proto::remove_player* remove_player_packet_;
+ ::proto::say* say_packet_;
+ ::proto::hear_player* hear_player_packet_;
+ ::proto::request_chunk* request_chunk_packet_;
+ ::proto::chunk* chunk_packet_;
+ ::proto::remove_chunk* remove_chunk_packet_;
+ ::proto::add_block* add_block_packet_;
+ ::proto::remove_block* remove_block_packet_;
+ ::proto::server_message* server_message_packet_;
+ } contents_;
+ mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+ uint32_t _oneof_case_[1];
+
+ friend struct ::TableStruct_net_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+ #pragma GCC diagnostic push
+ #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif // __GNUC__
+// angles
+
+// float pitch = 1;
+inline void angles::clear_pitch() {
+ pitch_ = 0;
+}
+inline float angles::_internal_pitch() const {
+ return pitch_;
+}
+inline float angles::pitch() const {
+ // @@protoc_insertion_point(field_get:proto.angles.pitch)
+ return _internal_pitch();
+}
+inline void angles::_internal_set_pitch(float value) {
+
+ pitch_ = value;
+}
+inline void angles::set_pitch(float value) {
+ _internal_set_pitch(value);
+ // @@protoc_insertion_point(field_set:proto.angles.pitch)
+}
+
+// float yaw = 2;
+inline void angles::clear_yaw() {
+ yaw_ = 0;
+}
+inline float angles::_internal_yaw() const {
+ return yaw_;
+}
+inline float angles::yaw() const {
+ // @@protoc_insertion_point(field_get:proto.angles.yaw)
+ return _internal_yaw();
+}
+inline void angles::_internal_set_yaw(float value) {
+
+ yaw_ = value;
+}
+inline void angles::set_yaw(float value) {
+ _internal_set_yaw(value);
+ // @@protoc_insertion_point(field_set:proto.angles.yaw)
+}
+
+// -------------------------------------------------------------------
+
+// coords
+
+// int32 x = 1;
+inline void coords::clear_x() {
+ x_ = 0;
+}
+inline int32_t coords::_internal_x() const {
+ return x_;
+}
+inline int32_t coords::x() const {
+ // @@protoc_insertion_point(field_get:proto.coords.x)
+ return _internal_x();
+}
+inline void coords::_internal_set_x(int32_t value) {
+
+ x_ = value;
+}
+inline void coords::set_x(int32_t value) {
+ _internal_set_x(value);
+ // @@protoc_insertion_point(field_set:proto.coords.x)
+}
+
+// int32 z = 2;
+inline void coords::clear_z() {
+ z_ = 0;
+}
+inline int32_t coords::_internal_z() const {
+ return z_;
+}
+inline int32_t coords::z() const {
+ // @@protoc_insertion_point(field_get:proto.coords.z)
+ return _internal_z();
+}
+inline void coords::_internal_set_z(int32_t value) {
+
+ z_ = value;
+}
+inline void coords::set_z(int32_t value) {
+ _internal_set_z(value);
+ // @@protoc_insertion_point(field_set:proto.coords.z)
+}
+
+// -------------------------------------------------------------------
+
+// vec3
+
+// float x = 1;
+inline void vec3::clear_x() {
+ x_ = 0;
+}
+inline float vec3::_internal_x() const {
+ return x_;
+}
+inline float vec3::x() const {
+ // @@protoc_insertion_point(field_get:proto.vec3.x)
+ return _internal_x();
+}
+inline void vec3::_internal_set_x(float value) {
+
+ x_ = value;
+}
+inline void vec3::set_x(float value) {
+ _internal_set_x(value);
+ // @@protoc_insertion_point(field_set:proto.vec3.x)
+}
+
+// float y = 2;
+inline void vec3::clear_y() {
+ y_ = 0;
+}
+inline float vec3::_internal_y() const {
+ return y_;
+}
+inline float vec3::y() const {
+ // @@protoc_insertion_point(field_get:proto.vec3.y)
+ return _internal_y();
+}
+inline void vec3::_internal_set_y(float value) {
+
+ y_ = value;
+}
+inline void vec3::set_y(float value) {
+ _internal_set_y(value);
+ // @@protoc_insertion_point(field_set:proto.vec3.y)
+}
+
+// float z = 3;
+inline void vec3::clear_z() {
+ z_ = 0;
+}
+inline float vec3::_internal_z() const {
+ return z_;
+}
+inline float vec3::z() const {
+ // @@protoc_insertion_point(field_get:proto.vec3.z)
+ return _internal_z();
+}
+inline void vec3::_internal_set_z(float value) {
+
+ z_ = value;
+}
+inline void vec3::set_z(float value) {
+ _internal_set_z(value);
+ // @@protoc_insertion_point(field_set:proto.vec3.z)
+}
+
+// -------------------------------------------------------------------
+
+// ivec3
+
+// int32 x = 1;
+inline void ivec3::clear_x() {
+ x_ = 0;
+}
+inline int32_t ivec3::_internal_x() const {
+ return x_;
+}
+inline int32_t ivec3::x() const {
+ // @@protoc_insertion_point(field_get:proto.ivec3.x)
+ return _internal_x();
+}
+inline void ivec3::_internal_set_x(int32_t value) {
+
+ x_ = value;
+}
+inline void ivec3::set_x(int32_t value) {
+ _internal_set_x(value);
+ // @@protoc_insertion_point(field_set:proto.ivec3.x)
+}
+
+// int32 y = 2;
+inline void ivec3::clear_y() {
+ y_ = 0;
+}
+inline int32_t ivec3::_internal_y() const {
+ return y_;
+}
+inline int32_t ivec3::y() const {
+ // @@protoc_insertion_point(field_get:proto.ivec3.y)
+ return _internal_y();
+}
+inline void ivec3::_internal_set_y(int32_t value) {
+
+ y_ = value;
+}
+inline void ivec3::set_y(int32_t value) {
+ _internal_set_y(value);
+ // @@protoc_insertion_point(field_set:proto.ivec3.y)
+}
+
+// int32 z = 3;
+inline void ivec3::clear_z() {
+ z_ = 0;
+}
+inline int32_t ivec3::_internal_z() const {
+ return z_;
+}
+inline int32_t ivec3::z() const {
+ // @@protoc_insertion_point(field_get:proto.ivec3.z)
+ return _internal_z();
+}
+inline void ivec3::_internal_set_z(int32_t value) {
+
+ z_ = value;
+}
+inline void ivec3::set_z(int32_t value) {
+ _internal_set_z(value);
+ // @@protoc_insertion_point(field_set:proto.ivec3.z)
+}
+
+// -------------------------------------------------------------------
+
+// player
+
+// uint32 index = 1;
+inline void player::clear_index() {
+ index_ = 0u;
+}
+inline uint32_t player::_internal_index() const {
+ return index_;
+}
+inline uint32_t player::index() const {
+ // @@protoc_insertion_point(field_get:proto.player.index)
+ return _internal_index();
+}
+inline void player::_internal_set_index(uint32_t value) {
+
+ index_ = value;
+}
+inline void player::set_index(uint32_t value) {
+ _internal_set_index(value);
+ // @@protoc_insertion_point(field_set:proto.player.index)
+}
+
+// uint32 commands = 2;
+inline void player::clear_commands() {
+ commands_ = 0u;
+}
+inline uint32_t player::_internal_commands() const {
+ return commands_;
+}
+inline uint32_t player::commands() const {
+ // @@protoc_insertion_point(field_get:proto.player.commands)
+ return _internal_commands();
+}
+inline void player::_internal_set_commands(uint32_t value) {
+
+ commands_ = value;
+}
+inline void player::set_commands(uint32_t value) {
+ _internal_set_commands(value);
+ // @@protoc_insertion_point(field_set:proto.player.commands)
+}
+
+// .proto.coords chunk_pos = 3;
+inline bool player::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool player::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void player::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& player::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& player::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.player.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void player::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.player.chunk_pos)
+}
+inline ::proto::coords* player::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* player::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.player.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* player::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* player::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.player.chunk_pos)
+ return _msg;
+}
+inline void player::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.player.chunk_pos)
+}
+
+// .proto.vec3 local_pos = 4;
+inline bool player::_internal_has_local_pos() const {
+ return this != internal_default_instance() && local_pos_ != nullptr;
+}
+inline bool player::has_local_pos() const {
+ return _internal_has_local_pos();
+}
+inline void player::clear_local_pos() {
+ if (GetArenaForAllocation() == nullptr && local_pos_ != nullptr) {
+ delete local_pos_;
+ }
+ local_pos_ = nullptr;
+}
+inline const ::proto::vec3& player::_internal_local_pos() const {
+ const ::proto::vec3* p = local_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::vec3&>(
+ ::proto::_vec3_default_instance_);
+}
+inline const ::proto::vec3& player::local_pos() const {
+ // @@protoc_insertion_point(field_get:proto.player.local_pos)
+ return _internal_local_pos();
+}
+inline void player::unsafe_arena_set_allocated_local_pos(
+ ::proto::vec3* local_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(local_pos_);
+ }
+ local_pos_ = local_pos;
+ if (local_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.player.local_pos)
+}
+inline ::proto::vec3* player::release_local_pos() {
+
+ ::proto::vec3* temp = local_pos_;
+ local_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::vec3* player::unsafe_arena_release_local_pos() {
+ // @@protoc_insertion_point(field_release:proto.player.local_pos)
+
+ ::proto::vec3* temp = local_pos_;
+ local_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::vec3* player::_internal_mutable_local_pos() {
+
+ if (local_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::vec3>(GetArenaForAllocation());
+ local_pos_ = p;
+ }
+ return local_pos_;
+}
+inline ::proto::vec3* player::mutable_local_pos() {
+ ::proto::vec3* _msg = _internal_mutable_local_pos();
+ // @@protoc_insertion_point(field_mutable:proto.player.local_pos)
+ return _msg;
+}
+inline void player::set_allocated_local_pos(::proto::vec3* local_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete local_pos_;
+ }
+ if (local_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::vec3>::GetOwningArena(local_pos);
+ if (message_arena != submessage_arena) {
+ local_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, local_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ local_pos_ = local_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.player.local_pos)
+}
+
+// .proto.angles viewangles = 5;
+inline bool player::_internal_has_viewangles() const {
+ return this != internal_default_instance() && viewangles_ != nullptr;
+}
+inline bool player::has_viewangles() const {
+ return _internal_has_viewangles();
+}
+inline void player::clear_viewangles() {
+ if (GetArenaForAllocation() == nullptr && viewangles_ != nullptr) {
+ delete viewangles_;
+ }
+ viewangles_ = nullptr;
+}
+inline const ::proto::angles& player::_internal_viewangles() const {
+ const ::proto::angles* p = viewangles_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::angles&>(
+ ::proto::_angles_default_instance_);
+}
+inline const ::proto::angles& player::viewangles() const {
+ // @@protoc_insertion_point(field_get:proto.player.viewangles)
+ return _internal_viewangles();
+}
+inline void player::unsafe_arena_set_allocated_viewangles(
+ ::proto::angles* viewangles) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(viewangles_);
+ }
+ viewangles_ = viewangles;
+ if (viewangles) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.player.viewangles)
+}
+inline ::proto::angles* player::release_viewangles() {
+
+ ::proto::angles* temp = viewangles_;
+ viewangles_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::angles* player::unsafe_arena_release_viewangles() {
+ // @@protoc_insertion_point(field_release:proto.player.viewangles)
+
+ ::proto::angles* temp = viewangles_;
+ viewangles_ = nullptr;
+ return temp;
+}
+inline ::proto::angles* player::_internal_mutable_viewangles() {
+
+ if (viewangles_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::angles>(GetArenaForAllocation());
+ viewangles_ = p;
+ }
+ return viewangles_;
+}
+inline ::proto::angles* player::mutable_viewangles() {
+ ::proto::angles* _msg = _internal_mutable_viewangles();
+ // @@protoc_insertion_point(field_mutable:proto.player.viewangles)
+ return _msg;
+}
+inline void player::set_allocated_viewangles(::proto::angles* viewangles) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete viewangles_;
+ }
+ if (viewangles) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::angles>::GetOwningArena(viewangles);
+ if (message_arena != submessage_arena) {
+ viewangles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, viewangles, submessage_arena);
+ }
+
+ } else {
+
+ }
+ viewangles_ = viewangles;
+ // @@protoc_insertion_point(field_set_allocated:proto.player.viewangles)
+}
+
+// .proto.vec3 velocity = 6;
+inline bool player::_internal_has_velocity() const {
+ return this != internal_default_instance() && velocity_ != nullptr;
+}
+inline bool player::has_velocity() const {
+ return _internal_has_velocity();
+}
+inline void player::clear_velocity() {
+ if (GetArenaForAllocation() == nullptr && velocity_ != nullptr) {
+ delete velocity_;
+ }
+ velocity_ = nullptr;
+}
+inline const ::proto::vec3& player::_internal_velocity() const {
+ const ::proto::vec3* p = velocity_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::vec3&>(
+ ::proto::_vec3_default_instance_);
+}
+inline const ::proto::vec3& player::velocity() const {
+ // @@protoc_insertion_point(field_get:proto.player.velocity)
+ return _internal_velocity();
+}
+inline void player::unsafe_arena_set_allocated_velocity(
+ ::proto::vec3* velocity) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(velocity_);
+ }
+ velocity_ = velocity;
+ if (velocity) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.player.velocity)
+}
+inline ::proto::vec3* player::release_velocity() {
+
+ ::proto::vec3* temp = velocity_;
+ velocity_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::vec3* player::unsafe_arena_release_velocity() {
+ // @@protoc_insertion_point(field_release:proto.player.velocity)
+
+ ::proto::vec3* temp = velocity_;
+ velocity_ = nullptr;
+ return temp;
+}
+inline ::proto::vec3* player::_internal_mutable_velocity() {
+
+ if (velocity_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::vec3>(GetArenaForAllocation());
+ velocity_ = p;
+ }
+ return velocity_;
+}
+inline ::proto::vec3* player::mutable_velocity() {
+ ::proto::vec3* _msg = _internal_mutable_velocity();
+ // @@protoc_insertion_point(field_mutable:proto.player.velocity)
+ return _msg;
+}
+inline void player::set_allocated_velocity(::proto::vec3* velocity) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete velocity_;
+ }
+ if (velocity) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::vec3>::GetOwningArena(velocity);
+ if (message_arena != submessage_arena) {
+ velocity = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, velocity, submessage_arena);
+ }
+
+ } else {
+
+ }
+ velocity_ = velocity;
+ // @@protoc_insertion_point(field_set_allocated:proto.player.velocity)
+}
+
+// -------------------------------------------------------------------
+
+// auth
+
+// string username = 1;
+inline void auth::clear_username() {
+ username_.ClearToEmpty();
+}
+inline const std::string& auth::username() const {
+ // @@protoc_insertion_point(field_get:proto.auth.username)
+ return _internal_username();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void auth::set_username(ArgT0&& arg0, ArgT... args) {
+
+ username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:proto.auth.username)
+}
+inline std::string* auth::mutable_username() {
+ std::string* _s = _internal_mutable_username();
+ // @@protoc_insertion_point(field_mutable:proto.auth.username)
+ return _s;
+}
+inline const std::string& auth::_internal_username() const {
+ return username_.Get();
+}
+inline void auth::_internal_set_username(const std::string& value) {
+
+ username_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* auth::_internal_mutable_username() {
+
+ return username_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* auth::release_username() {
+ // @@protoc_insertion_point(field_release:proto.auth.username)
+ return username_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void auth::set_allocated_username(std::string* username) {
+ if (username != nullptr) {
+
+ } else {
+
+ }
+ username_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), username,
+ GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (username_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+ username_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ // @@protoc_insertion_point(field_set_allocated:proto.auth.username)
+}
+
+// string password = 2;
+inline void auth::clear_password() {
+ password_.ClearToEmpty();
+}
+inline const std::string& auth::password() const {
+ // @@protoc_insertion_point(field_get:proto.auth.password)
+ return _internal_password();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void auth::set_password(ArgT0&& arg0, ArgT... args) {
+
+ password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:proto.auth.password)
+}
+inline std::string* auth::mutable_password() {
+ std::string* _s = _internal_mutable_password();
+ // @@protoc_insertion_point(field_mutable:proto.auth.password)
+ return _s;
+}
+inline const std::string& auth::_internal_password() const {
+ return password_.Get();
+}
+inline void auth::_internal_set_password(const std::string& value) {
+
+ password_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* auth::_internal_mutable_password() {
+
+ return password_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* auth::release_password() {
+ // @@protoc_insertion_point(field_release:proto.auth.password)
+ return password_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void auth::set_allocated_password(std::string* password) {
+ if (password != nullptr) {
+
+ } else {
+
+ }
+ password_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), password,
+ GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (password_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+ password_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ // @@protoc_insertion_point(field_set_allocated:proto.auth.password)
+}
+
+// -------------------------------------------------------------------
+
+// init
+
+// uint64 seed = 1;
+inline void init::clear_seed() {
+ seed_ = uint64_t{0u};
+}
+inline uint64_t init::_internal_seed() const {
+ return seed_;
+}
+inline uint64_t init::seed() const {
+ // @@protoc_insertion_point(field_get:proto.init.seed)
+ return _internal_seed();
+}
+inline void init::_internal_set_seed(uint64_t value) {
+
+ seed_ = value;
+}
+inline void init::set_seed(uint64_t value) {
+ _internal_set_seed(value);
+ // @@protoc_insertion_point(field_set:proto.init.seed)
+}
+
+// int32 draw_distance = 2;
+inline void init::clear_draw_distance() {
+ draw_distance_ = 0;
+}
+inline int32_t init::_internal_draw_distance() const {
+ return draw_distance_;
+}
+inline int32_t init::draw_distance() const {
+ // @@protoc_insertion_point(field_get:proto.init.draw_distance)
+ return _internal_draw_distance();
+}
+inline void init::_internal_set_draw_distance(int32_t value) {
+
+ draw_distance_ = value;
+}
+inline void init::set_draw_distance(int32_t value) {
+ _internal_set_draw_distance(value);
+ // @@protoc_insertion_point(field_set:proto.init.draw_distance)
+}
+
+// .proto.player localplayer = 3;
+inline bool init::_internal_has_localplayer() const {
+ return this != internal_default_instance() && localplayer_ != nullptr;
+}
+inline bool init::has_localplayer() const {
+ return _internal_has_localplayer();
+}
+inline void init::clear_localplayer() {
+ if (GetArenaForAllocation() == nullptr && localplayer_ != nullptr) {
+ delete localplayer_;
+ }
+ localplayer_ = nullptr;
+}
+inline const ::proto::player& init::_internal_localplayer() const {
+ const ::proto::player* p = localplayer_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::player&>(
+ ::proto::_player_default_instance_);
+}
+inline const ::proto::player& init::localplayer() const {
+ // @@protoc_insertion_point(field_get:proto.init.localplayer)
+ return _internal_localplayer();
+}
+inline void init::unsafe_arena_set_allocated_localplayer(
+ ::proto::player* localplayer) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(localplayer_);
+ }
+ localplayer_ = localplayer;
+ if (localplayer) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.init.localplayer)
+}
+inline ::proto::player* init::release_localplayer() {
+
+ ::proto::player* temp = localplayer_;
+ localplayer_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::player* init::unsafe_arena_release_localplayer() {
+ // @@protoc_insertion_point(field_release:proto.init.localplayer)
+
+ ::proto::player* temp = localplayer_;
+ localplayer_ = nullptr;
+ return temp;
+}
+inline ::proto::player* init::_internal_mutable_localplayer() {
+
+ if (localplayer_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::player>(GetArenaForAllocation());
+ localplayer_ = p;
+ }
+ return localplayer_;
+}
+inline ::proto::player* init::mutable_localplayer() {
+ ::proto::player* _msg = _internal_mutable_localplayer();
+ // @@protoc_insertion_point(field_mutable:proto.init.localplayer)
+ return _msg;
+}
+inline void init::set_allocated_localplayer(::proto::player* localplayer) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete localplayer_;
+ }
+ if (localplayer) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::player>::GetOwningArena(localplayer);
+ if (message_arena != submessage_arena) {
+ localplayer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, localplayer, submessage_arena);
+ }
+
+ } else {
+
+ }
+ localplayer_ = localplayer;
+ // @@protoc_insertion_point(field_set_allocated:proto.init.localplayer)
+}
+
+// -------------------------------------------------------------------
+
+// move
+
+// uint32 commands = 1;
+inline void move::clear_commands() {
+ commands_ = 0u;
+}
+inline uint32_t move::_internal_commands() const {
+ return commands_;
+}
+inline uint32_t move::commands() const {
+ // @@protoc_insertion_point(field_get:proto.move.commands)
+ return _internal_commands();
+}
+inline void move::_internal_set_commands(uint32_t value) {
+
+ commands_ = value;
+}
+inline void move::set_commands(uint32_t value) {
+ _internal_set_commands(value);
+ // @@protoc_insertion_point(field_set:proto.move.commands)
+}
+
+// .proto.angles viewangles = 2;
+inline bool move::_internal_has_viewangles() const {
+ return this != internal_default_instance() && viewangles_ != nullptr;
+}
+inline bool move::has_viewangles() const {
+ return _internal_has_viewangles();
+}
+inline void move::clear_viewangles() {
+ if (GetArenaForAllocation() == nullptr && viewangles_ != nullptr) {
+ delete viewangles_;
+ }
+ viewangles_ = nullptr;
+}
+inline const ::proto::angles& move::_internal_viewangles() const {
+ const ::proto::angles* p = viewangles_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::angles&>(
+ ::proto::_angles_default_instance_);
+}
+inline const ::proto::angles& move::viewangles() const {
+ // @@protoc_insertion_point(field_get:proto.move.viewangles)
+ return _internal_viewangles();
+}
+inline void move::unsafe_arena_set_allocated_viewangles(
+ ::proto::angles* viewangles) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(viewangles_);
+ }
+ viewangles_ = viewangles;
+ if (viewangles) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.move.viewangles)
+}
+inline ::proto::angles* move::release_viewangles() {
+
+ ::proto::angles* temp = viewangles_;
+ viewangles_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::angles* move::unsafe_arena_release_viewangles() {
+ // @@protoc_insertion_point(field_release:proto.move.viewangles)
+
+ ::proto::angles* temp = viewangles_;
+ viewangles_ = nullptr;
+ return temp;
+}
+inline ::proto::angles* move::_internal_mutable_viewangles() {
+
+ if (viewangles_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::angles>(GetArenaForAllocation());
+ viewangles_ = p;
+ }
+ return viewangles_;
+}
+inline ::proto::angles* move::mutable_viewangles() {
+ ::proto::angles* _msg = _internal_mutable_viewangles();
+ // @@protoc_insertion_point(field_mutable:proto.move.viewangles)
+ return _msg;
+}
+inline void move::set_allocated_viewangles(::proto::angles* viewangles) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete viewangles_;
+ }
+ if (viewangles) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::angles>::GetOwningArena(viewangles);
+ if (message_arena != submessage_arena) {
+ viewangles = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, viewangles, submessage_arena);
+ }
+
+ } else {
+
+ }
+ viewangles_ = viewangles;
+ // @@protoc_insertion_point(field_set_allocated:proto.move.viewangles)
+}
+
+// -------------------------------------------------------------------
+
+// remove_player
+
+// uint32 index = 1;
+inline void remove_player::clear_index() {
+ index_ = 0u;
+}
+inline uint32_t remove_player::_internal_index() const {
+ return index_;
+}
+inline uint32_t remove_player::index() const {
+ // @@protoc_insertion_point(field_get:proto.remove_player.index)
+ return _internal_index();
+}
+inline void remove_player::_internal_set_index(uint32_t value) {
+
+ index_ = value;
+}
+inline void remove_player::set_index(uint32_t value) {
+ _internal_set_index(value);
+ // @@protoc_insertion_point(field_set:proto.remove_player.index)
+}
+
+// -------------------------------------------------------------------
+
+// say
+
+// string text = 1;
+inline void say::clear_text() {
+ text_.ClearToEmpty();
+}
+inline const std::string& say::text() const {
+ // @@protoc_insertion_point(field_get:proto.say.text)
+ return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void say::set_text(ArgT0&& arg0, ArgT... args) {
+
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:proto.say.text)
+}
+inline std::string* say::mutable_text() {
+ std::string* _s = _internal_mutable_text();
+ // @@protoc_insertion_point(field_mutable:proto.say.text)
+ return _s;
+}
+inline const std::string& say::_internal_text() const {
+ return text_.Get();
+}
+inline void say::_internal_set_text(const std::string& value) {
+
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* say::_internal_mutable_text() {
+
+ return text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* say::release_text() {
+ // @@protoc_insertion_point(field_release:proto.say.text)
+ return text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void say::set_allocated_text(std::string* text) {
+ if (text != nullptr) {
+
+ } else {
+
+ }
+ text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), text,
+ GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (text_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ // @@protoc_insertion_point(field_set_allocated:proto.say.text)
+}
+
+// -------------------------------------------------------------------
+
+// hear_player
+
+// uint32 index = 1;
+inline void hear_player::clear_index() {
+ index_ = 0u;
+}
+inline uint32_t hear_player::_internal_index() const {
+ return index_;
+}
+inline uint32_t hear_player::index() const {
+ // @@protoc_insertion_point(field_get:proto.hear_player.index)
+ return _internal_index();
+}
+inline void hear_player::_internal_set_index(uint32_t value) {
+
+ index_ = value;
+}
+inline void hear_player::set_index(uint32_t value) {
+ _internal_set_index(value);
+ // @@protoc_insertion_point(field_set:proto.hear_player.index)
+}
+
+// string text = 2;
+inline void hear_player::clear_text() {
+ text_.ClearToEmpty();
+}
+inline const std::string& hear_player::text() const {
+ // @@protoc_insertion_point(field_get:proto.hear_player.text)
+ return _internal_text();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void hear_player::set_text(ArgT0&& arg0, ArgT... args) {
+
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:proto.hear_player.text)
+}
+inline std::string* hear_player::mutable_text() {
+ std::string* _s = _internal_mutable_text();
+ // @@protoc_insertion_point(field_mutable:proto.hear_player.text)
+ return _s;
+}
+inline const std::string& hear_player::_internal_text() const {
+ return text_.Get();
+}
+inline void hear_player::_internal_set_text(const std::string& value) {
+
+ text_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* hear_player::_internal_mutable_text() {
+
+ return text_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* hear_player::release_text() {
+ // @@protoc_insertion_point(field_release:proto.hear_player.text)
+ return text_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void hear_player::set_allocated_text(std::string* text) {
+ if (text != nullptr) {
+
+ } else {
+
+ }
+ text_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), text,
+ GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (text_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+ text_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ // @@protoc_insertion_point(field_set_allocated:proto.hear_player.text)
+}
+
+// -------------------------------------------------------------------
+
+// request_chunk
+
+// .proto.coords chunk_pos = 1;
+inline bool request_chunk::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool request_chunk::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void request_chunk::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& request_chunk::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& request_chunk::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.request_chunk.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void request_chunk::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.request_chunk.chunk_pos)
+}
+inline ::proto::coords* request_chunk::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* request_chunk::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.request_chunk.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* request_chunk::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* request_chunk::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.request_chunk.chunk_pos)
+ return _msg;
+}
+inline void request_chunk::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.request_chunk.chunk_pos)
+}
+
+// -------------------------------------------------------------------
+
+// remove_chunk
+
+// .proto.coords chunk_pos = 1;
+inline bool remove_chunk::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool remove_chunk::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void remove_chunk::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& remove_chunk::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& remove_chunk::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.remove_chunk.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void remove_chunk::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.remove_chunk.chunk_pos)
+}
+inline ::proto::coords* remove_chunk::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* remove_chunk::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.remove_chunk.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* remove_chunk::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* remove_chunk::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.remove_chunk.chunk_pos)
+ return _msg;
+}
+inline void remove_chunk::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.remove_chunk.chunk_pos)
+}
+
+// -------------------------------------------------------------------
+
+// chunk
+
+// .proto.coords chunk_pos = 1;
+inline bool chunk::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool chunk::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void chunk::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& chunk::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& chunk::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.chunk.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void chunk::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.chunk.chunk_pos)
+}
+inline ::proto::coords* chunk::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* chunk::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.chunk.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* chunk::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* chunk::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.chunk.chunk_pos)
+ return _msg;
+}
+inline void chunk::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.chunk.chunk_pos)
+}
+
+// repeated uint32 blocks = 2 [packed = true];
+inline int chunk::_internal_blocks_size() const {
+ return blocks_.size();
+}
+inline int chunk::blocks_size() const {
+ return _internal_blocks_size();
+}
+inline void chunk::clear_blocks() {
+ blocks_.Clear();
+}
+inline uint32_t chunk::_internal_blocks(int index) const {
+ return blocks_.Get(index);
+}
+inline uint32_t chunk::blocks(int index) const {
+ // @@protoc_insertion_point(field_get:proto.chunk.blocks)
+ return _internal_blocks(index);
+}
+inline void chunk::set_blocks(int index, uint32_t value) {
+ blocks_.Set(index, value);
+ // @@protoc_insertion_point(field_set:proto.chunk.blocks)
+}
+inline void chunk::_internal_add_blocks(uint32_t value) {
+ blocks_.Add(value);
+}
+inline void chunk::add_blocks(uint32_t value) {
+ _internal_add_blocks(value);
+ // @@protoc_insertion_point(field_add:proto.chunk.blocks)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+chunk::_internal_blocks() const {
+ return blocks_;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >&
+chunk::blocks() const {
+ // @@protoc_insertion_point(field_list:proto.chunk.blocks)
+ return _internal_blocks();
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+chunk::_internal_mutable_blocks() {
+ return &blocks_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField< uint32_t >*
+chunk::mutable_blocks() {
+ // @@protoc_insertion_point(field_mutable_list:proto.chunk.blocks)
+ return _internal_mutable_blocks();
+}
+
+// -------------------------------------------------------------------
+
+// add_block
+
+// .proto.coords chunk_pos = 1;
+inline bool add_block::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool add_block::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void add_block::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& add_block::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& add_block::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.add_block.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void add_block::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.add_block.chunk_pos)
+}
+inline ::proto::coords* add_block::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* add_block::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.add_block.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* add_block::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* add_block::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.add_block.chunk_pos)
+ return _msg;
+}
+inline void add_block::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.add_block.chunk_pos)
+}
+
+// .proto.ivec3 block_pos = 2;
+inline bool add_block::_internal_has_block_pos() const {
+ return this != internal_default_instance() && block_pos_ != nullptr;
+}
+inline bool add_block::has_block_pos() const {
+ return _internal_has_block_pos();
+}
+inline void add_block::clear_block_pos() {
+ if (GetArenaForAllocation() == nullptr && block_pos_ != nullptr) {
+ delete block_pos_;
+ }
+ block_pos_ = nullptr;
+}
+inline const ::proto::ivec3& add_block::_internal_block_pos() const {
+ const ::proto::ivec3* p = block_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::ivec3&>(
+ ::proto::_ivec3_default_instance_);
+}
+inline const ::proto::ivec3& add_block::block_pos() const {
+ // @@protoc_insertion_point(field_get:proto.add_block.block_pos)
+ return _internal_block_pos();
+}
+inline void add_block::unsafe_arena_set_allocated_block_pos(
+ ::proto::ivec3* block_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_pos_);
+ }
+ block_pos_ = block_pos;
+ if (block_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.add_block.block_pos)
+}
+inline ::proto::ivec3* add_block::release_block_pos() {
+
+ ::proto::ivec3* temp = block_pos_;
+ block_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::ivec3* add_block::unsafe_arena_release_block_pos() {
+ // @@protoc_insertion_point(field_release:proto.add_block.block_pos)
+
+ ::proto::ivec3* temp = block_pos_;
+ block_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::ivec3* add_block::_internal_mutable_block_pos() {
+
+ if (block_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::ivec3>(GetArenaForAllocation());
+ block_pos_ = p;
+ }
+ return block_pos_;
+}
+inline ::proto::ivec3* add_block::mutable_block_pos() {
+ ::proto::ivec3* _msg = _internal_mutable_block_pos();
+ // @@protoc_insertion_point(field_mutable:proto.add_block.block_pos)
+ return _msg;
+}
+inline void add_block::set_allocated_block_pos(::proto::ivec3* block_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete block_pos_;
+ }
+ if (block_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::ivec3>::GetOwningArena(block_pos);
+ if (message_arena != submessage_arena) {
+ block_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, block_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ block_pos_ = block_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.add_block.block_pos)
+}
+
+// uint32 block = 3;
+inline void add_block::clear_block() {
+ block_ = 0u;
+}
+inline uint32_t add_block::_internal_block() const {
+ return block_;
+}
+inline uint32_t add_block::block() const {
+ // @@protoc_insertion_point(field_get:proto.add_block.block)
+ return _internal_block();
+}
+inline void add_block::_internal_set_block(uint32_t value) {
+
+ block_ = value;
+}
+inline void add_block::set_block(uint32_t value) {
+ _internal_set_block(value);
+ // @@protoc_insertion_point(field_set:proto.add_block.block)
+}
+
+// -------------------------------------------------------------------
+
+// remove_block
+
+// .proto.coords chunk_pos = 1;
+inline bool remove_block::_internal_has_chunk_pos() const {
+ return this != internal_default_instance() && chunk_pos_ != nullptr;
+}
+inline bool remove_block::has_chunk_pos() const {
+ return _internal_has_chunk_pos();
+}
+inline void remove_block::clear_chunk_pos() {
+ if (GetArenaForAllocation() == nullptr && chunk_pos_ != nullptr) {
+ delete chunk_pos_;
+ }
+ chunk_pos_ = nullptr;
+}
+inline const ::proto::coords& remove_block::_internal_chunk_pos() const {
+ const ::proto::coords* p = chunk_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::coords&>(
+ ::proto::_coords_default_instance_);
+}
+inline const ::proto::coords& remove_block::chunk_pos() const {
+ // @@protoc_insertion_point(field_get:proto.remove_block.chunk_pos)
+ return _internal_chunk_pos();
+}
+inline void remove_block::unsafe_arena_set_allocated_chunk_pos(
+ ::proto::coords* chunk_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(chunk_pos_);
+ }
+ chunk_pos_ = chunk_pos;
+ if (chunk_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.remove_block.chunk_pos)
+}
+inline ::proto::coords* remove_block::release_chunk_pos() {
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::coords* remove_block::unsafe_arena_release_chunk_pos() {
+ // @@protoc_insertion_point(field_release:proto.remove_block.chunk_pos)
+
+ ::proto::coords* temp = chunk_pos_;
+ chunk_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::coords* remove_block::_internal_mutable_chunk_pos() {
+
+ if (chunk_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::coords>(GetArenaForAllocation());
+ chunk_pos_ = p;
+ }
+ return chunk_pos_;
+}
+inline ::proto::coords* remove_block::mutable_chunk_pos() {
+ ::proto::coords* _msg = _internal_mutable_chunk_pos();
+ // @@protoc_insertion_point(field_mutable:proto.remove_block.chunk_pos)
+ return _msg;
+}
+inline void remove_block::set_allocated_chunk_pos(::proto::coords* chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete chunk_pos_;
+ }
+ if (chunk_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::coords>::GetOwningArena(chunk_pos);
+ if (message_arena != submessage_arena) {
+ chunk_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, chunk_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ chunk_pos_ = chunk_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.remove_block.chunk_pos)
+}
+
+// .proto.ivec3 block_pos = 2;
+inline bool remove_block::_internal_has_block_pos() const {
+ return this != internal_default_instance() && block_pos_ != nullptr;
+}
+inline bool remove_block::has_block_pos() const {
+ return _internal_has_block_pos();
+}
+inline void remove_block::clear_block_pos() {
+ if (GetArenaForAllocation() == nullptr && block_pos_ != nullptr) {
+ delete block_pos_;
+ }
+ block_pos_ = nullptr;
+}
+inline const ::proto::ivec3& remove_block::_internal_block_pos() const {
+ const ::proto::ivec3* p = block_pos_;
+ return p != nullptr ? *p : reinterpret_cast<const ::proto::ivec3&>(
+ ::proto::_ivec3_default_instance_);
+}
+inline const ::proto::ivec3& remove_block::block_pos() const {
+ // @@protoc_insertion_point(field_get:proto.remove_block.block_pos)
+ return _internal_block_pos();
+}
+inline void remove_block::unsafe_arena_set_allocated_block_pos(
+ ::proto::ivec3* block_pos) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(block_pos_);
+ }
+ block_pos_ = block_pos;
+ if (block_pos) {
+
+ } else {
+
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.remove_block.block_pos)
+}
+inline ::proto::ivec3* remove_block::release_block_pos() {
+
+ ::proto::ivec3* temp = block_pos_;
+ block_pos_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+ auto* old = reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ if (GetArenaForAllocation() == nullptr) { delete old; }
+#else // PROTOBUF_FORCE_COPY_IN_RELEASE
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+#endif // !PROTOBUF_FORCE_COPY_IN_RELEASE
+ return temp;
+}
+inline ::proto::ivec3* remove_block::unsafe_arena_release_block_pos() {
+ // @@protoc_insertion_point(field_release:proto.remove_block.block_pos)
+
+ ::proto::ivec3* temp = block_pos_;
+ block_pos_ = nullptr;
+ return temp;
+}
+inline ::proto::ivec3* remove_block::_internal_mutable_block_pos() {
+
+ if (block_pos_ == nullptr) {
+ auto* p = CreateMaybeMessage<::proto::ivec3>(GetArenaForAllocation());
+ block_pos_ = p;
+ }
+ return block_pos_;
+}
+inline ::proto::ivec3* remove_block::mutable_block_pos() {
+ ::proto::ivec3* _msg = _internal_mutable_block_pos();
+ // @@protoc_insertion_point(field_mutable:proto.remove_block.block_pos)
+ return _msg;
+}
+inline void remove_block::set_allocated_block_pos(::proto::ivec3* block_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+ if (message_arena == nullptr) {
+ delete block_pos_;
+ }
+ if (block_pos) {
+ ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+ ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::proto::ivec3>::GetOwningArena(block_pos);
+ if (message_arena != submessage_arena) {
+ block_pos = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+ message_arena, block_pos, submessage_arena);
+ }
+
+ } else {
+
+ }
+ block_pos_ = block_pos;
+ // @@protoc_insertion_point(field_set_allocated:proto.remove_block.block_pos)
+}
+
+// -------------------------------------------------------------------
+
+// server_message
+
+// string message = 1;
+inline void server_message::clear_message() {
+ message_.ClearToEmpty();
+}
+inline const std::string& server_message::message() const {
+ // @@protoc_insertion_point(field_get:proto.server_message.message)
+ return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void server_message::set_message(ArgT0&& arg0, ArgT... args) {
+
+ message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+ // @@protoc_insertion_point(field_set:proto.server_message.message)
+}
+inline std::string* server_message::mutable_message() {
+ std::string* _s = _internal_mutable_message();
+ // @@protoc_insertion_point(field_mutable:proto.server_message.message)
+ return _s;
+}
+inline const std::string& server_message::_internal_message() const {
+ return message_.Get();
+}
+inline void server_message::_internal_set_message(const std::string& value) {
+
+ message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* server_message::_internal_mutable_message() {
+
+ return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* server_message::release_message() {
+ // @@protoc_insertion_point(field_release:proto.server_message.message)
+ return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void server_message::set_allocated_message(std::string* message) {
+ if (message != nullptr) {
+
+ } else {
+
+ }
+ message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
+ GetArenaForAllocation());
+#ifdef PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ if (message_.IsDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited())) {
+ message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), "", GetArenaForAllocation());
+ }
+#endif // PROTOBUF_FORCE_COPY_DEFAULT_STRING
+ // @@protoc_insertion_point(field_set_allocated:proto.server_message.message)
+}
+
+// bool fatal = 2;
+inline void server_message::clear_fatal() {
+ fatal_ = false;
+}
+inline bool server_message::_internal_fatal() const {
+ return fatal_;
+}
+inline bool server_message::fatal() const {
+ // @@protoc_insertion_point(field_get:proto.server_message.fatal)
+ return _internal_fatal();
+}
+inline void server_message::_internal_set_fatal(bool value) {
+
+ fatal_ = value;
+}
+inline void server_message::set_fatal(bool value) {
+ _internal_set_fatal(value);
+ // @@protoc_insertion_point(field_set:proto.server_message.fatal)
+}
+
+// -------------------------------------------------------------------
+
+// packet
+
+// .proto.auth auth_packet = 1;
+inline bool packet::_internal_has_auth_packet() const {
+ return contents_case() == kAuthPacket;
+}
+inline bool packet::has_auth_packet() const {
+ return _internal_has_auth_packet();
+}
+inline void packet::set_has_auth_packet() {
+ _oneof_case_[0] = kAuthPacket;
+}
+inline void packet::clear_auth_packet() {
+ if (_internal_has_auth_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.auth_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::auth* packet::release_auth_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.auth_packet)
+ if (_internal_has_auth_packet()) {
+ clear_has_contents();
+ ::proto::auth* temp = contents_.auth_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.auth_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::auth& packet::_internal_auth_packet() const {
+ return _internal_has_auth_packet()
+ ? *contents_.auth_packet_
+ : reinterpret_cast< ::proto::auth&>(::proto::_auth_default_instance_);
+}
+inline const ::proto::auth& packet::auth_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.auth_packet)
+ return _internal_auth_packet();
+}
+inline ::proto::auth* packet::unsafe_arena_release_auth_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.auth_packet)
+ if (_internal_has_auth_packet()) {
+ clear_has_contents();
+ ::proto::auth* temp = contents_.auth_packet_;
+ contents_.auth_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_auth_packet(::proto::auth* auth_packet) {
+ clear_contents();
+ if (auth_packet) {
+ set_has_auth_packet();
+ contents_.auth_packet_ = auth_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.auth_packet)
+}
+inline ::proto::auth* packet::_internal_mutable_auth_packet() {
+ if (!_internal_has_auth_packet()) {
+ clear_contents();
+ set_has_auth_packet();
+ contents_.auth_packet_ = CreateMaybeMessage< ::proto::auth >(GetArenaForAllocation());
+ }
+ return contents_.auth_packet_;
+}
+inline ::proto::auth* packet::mutable_auth_packet() {
+ ::proto::auth* _msg = _internal_mutable_auth_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.auth_packet)
+ return _msg;
+}
+
+// .proto.init init_packet = 2;
+inline bool packet::_internal_has_init_packet() const {
+ return contents_case() == kInitPacket;
+}
+inline bool packet::has_init_packet() const {
+ return _internal_has_init_packet();
+}
+inline void packet::set_has_init_packet() {
+ _oneof_case_[0] = kInitPacket;
+}
+inline void packet::clear_init_packet() {
+ if (_internal_has_init_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.init_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::init* packet::release_init_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.init_packet)
+ if (_internal_has_init_packet()) {
+ clear_has_contents();
+ ::proto::init* temp = contents_.init_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.init_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::init& packet::_internal_init_packet() const {
+ return _internal_has_init_packet()
+ ? *contents_.init_packet_
+ : reinterpret_cast< ::proto::init&>(::proto::_init_default_instance_);
+}
+inline const ::proto::init& packet::init_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.init_packet)
+ return _internal_init_packet();
+}
+inline ::proto::init* packet::unsafe_arena_release_init_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.init_packet)
+ if (_internal_has_init_packet()) {
+ clear_has_contents();
+ ::proto::init* temp = contents_.init_packet_;
+ contents_.init_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_init_packet(::proto::init* init_packet) {
+ clear_contents();
+ if (init_packet) {
+ set_has_init_packet();
+ contents_.init_packet_ = init_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.init_packet)
+}
+inline ::proto::init* packet::_internal_mutable_init_packet() {
+ if (!_internal_has_init_packet()) {
+ clear_contents();
+ set_has_init_packet();
+ contents_.init_packet_ = CreateMaybeMessage< ::proto::init >(GetArenaForAllocation());
+ }
+ return contents_.init_packet_;
+}
+inline ::proto::init* packet::mutable_init_packet() {
+ ::proto::init* _msg = _internal_mutable_init_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.init_packet)
+ return _msg;
+}
+
+// .proto.move move_packet = 3;
+inline bool packet::_internal_has_move_packet() const {
+ return contents_case() == kMovePacket;
+}
+inline bool packet::has_move_packet() const {
+ return _internal_has_move_packet();
+}
+inline void packet::set_has_move_packet() {
+ _oneof_case_[0] = kMovePacket;
+}
+inline void packet::clear_move_packet() {
+ if (_internal_has_move_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.move_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::move* packet::release_move_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.move_packet)
+ if (_internal_has_move_packet()) {
+ clear_has_contents();
+ ::proto::move* temp = contents_.move_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.move_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::move& packet::_internal_move_packet() const {
+ return _internal_has_move_packet()
+ ? *contents_.move_packet_
+ : reinterpret_cast< ::proto::move&>(::proto::_move_default_instance_);
+}
+inline const ::proto::move& packet::move_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.move_packet)
+ return _internal_move_packet();
+}
+inline ::proto::move* packet::unsafe_arena_release_move_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.move_packet)
+ if (_internal_has_move_packet()) {
+ clear_has_contents();
+ ::proto::move* temp = contents_.move_packet_;
+ contents_.move_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_move_packet(::proto::move* move_packet) {
+ clear_contents();
+ if (move_packet) {
+ set_has_move_packet();
+ contents_.move_packet_ = move_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.move_packet)
+}
+inline ::proto::move* packet::_internal_mutable_move_packet() {
+ if (!_internal_has_move_packet()) {
+ clear_contents();
+ set_has_move_packet();
+ contents_.move_packet_ = CreateMaybeMessage< ::proto::move >(GetArenaForAllocation());
+ }
+ return contents_.move_packet_;
+}
+inline ::proto::move* packet::mutable_move_packet() {
+ ::proto::move* _msg = _internal_mutable_move_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.move_packet)
+ return _msg;
+}
+
+// .proto.player player_packet = 4;
+inline bool packet::_internal_has_player_packet() const {
+ return contents_case() == kPlayerPacket;
+}
+inline bool packet::has_player_packet() const {
+ return _internal_has_player_packet();
+}
+inline void packet::set_has_player_packet() {
+ _oneof_case_[0] = kPlayerPacket;
+}
+inline void packet::clear_player_packet() {
+ if (_internal_has_player_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.player_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::player* packet::release_player_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.player_packet)
+ if (_internal_has_player_packet()) {
+ clear_has_contents();
+ ::proto::player* temp = contents_.player_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::player& packet::_internal_player_packet() const {
+ return _internal_has_player_packet()
+ ? *contents_.player_packet_
+ : reinterpret_cast< ::proto::player&>(::proto::_player_default_instance_);
+}
+inline const ::proto::player& packet::player_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.player_packet)
+ return _internal_player_packet();
+}
+inline ::proto::player* packet::unsafe_arena_release_player_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.player_packet)
+ if (_internal_has_player_packet()) {
+ clear_has_contents();
+ ::proto::player* temp = contents_.player_packet_;
+ contents_.player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_player_packet(::proto::player* player_packet) {
+ clear_contents();
+ if (player_packet) {
+ set_has_player_packet();
+ contents_.player_packet_ = player_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.player_packet)
+}
+inline ::proto::player* packet::_internal_mutable_player_packet() {
+ if (!_internal_has_player_packet()) {
+ clear_contents();
+ set_has_player_packet();
+ contents_.player_packet_ = CreateMaybeMessage< ::proto::player >(GetArenaForAllocation());
+ }
+ return contents_.player_packet_;
+}
+inline ::proto::player* packet::mutable_player_packet() {
+ ::proto::player* _msg = _internal_mutable_player_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.player_packet)
+ return _msg;
+}
+
+// .proto.remove_player remove_player_packet = 5;
+inline bool packet::_internal_has_remove_player_packet() const {
+ return contents_case() == kRemovePlayerPacket;
+}
+inline bool packet::has_remove_player_packet() const {
+ return _internal_has_remove_player_packet();
+}
+inline void packet::set_has_remove_player_packet() {
+ _oneof_case_[0] = kRemovePlayerPacket;
+}
+inline void packet::clear_remove_player_packet() {
+ if (_internal_has_remove_player_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_player_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::remove_player* packet::release_remove_player_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.remove_player_packet)
+ if (_internal_has_remove_player_packet()) {
+ clear_has_contents();
+ ::proto::remove_player* temp = contents_.remove_player_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.remove_player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::remove_player& packet::_internal_remove_player_packet() const {
+ return _internal_has_remove_player_packet()
+ ? *contents_.remove_player_packet_
+ : reinterpret_cast< ::proto::remove_player&>(::proto::_remove_player_default_instance_);
+}
+inline const ::proto::remove_player& packet::remove_player_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.remove_player_packet)
+ return _internal_remove_player_packet();
+}
+inline ::proto::remove_player* packet::unsafe_arena_release_remove_player_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.remove_player_packet)
+ if (_internal_has_remove_player_packet()) {
+ clear_has_contents();
+ ::proto::remove_player* temp = contents_.remove_player_packet_;
+ contents_.remove_player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_remove_player_packet(::proto::remove_player* remove_player_packet) {
+ clear_contents();
+ if (remove_player_packet) {
+ set_has_remove_player_packet();
+ contents_.remove_player_packet_ = remove_player_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.remove_player_packet)
+}
+inline ::proto::remove_player* packet::_internal_mutable_remove_player_packet() {
+ if (!_internal_has_remove_player_packet()) {
+ clear_contents();
+ set_has_remove_player_packet();
+ contents_.remove_player_packet_ = CreateMaybeMessage< ::proto::remove_player >(GetArenaForAllocation());
+ }
+ return contents_.remove_player_packet_;
+}
+inline ::proto::remove_player* packet::mutable_remove_player_packet() {
+ ::proto::remove_player* _msg = _internal_mutable_remove_player_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.remove_player_packet)
+ return _msg;
+}
+
+// .proto.say say_packet = 6;
+inline bool packet::_internal_has_say_packet() const {
+ return contents_case() == kSayPacket;
+}
+inline bool packet::has_say_packet() const {
+ return _internal_has_say_packet();
+}
+inline void packet::set_has_say_packet() {
+ _oneof_case_[0] = kSayPacket;
+}
+inline void packet::clear_say_packet() {
+ if (_internal_has_say_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.say_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::say* packet::release_say_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.say_packet)
+ if (_internal_has_say_packet()) {
+ clear_has_contents();
+ ::proto::say* temp = contents_.say_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.say_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::say& packet::_internal_say_packet() const {
+ return _internal_has_say_packet()
+ ? *contents_.say_packet_
+ : reinterpret_cast< ::proto::say&>(::proto::_say_default_instance_);
+}
+inline const ::proto::say& packet::say_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.say_packet)
+ return _internal_say_packet();
+}
+inline ::proto::say* packet::unsafe_arena_release_say_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.say_packet)
+ if (_internal_has_say_packet()) {
+ clear_has_contents();
+ ::proto::say* temp = contents_.say_packet_;
+ contents_.say_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_say_packet(::proto::say* say_packet) {
+ clear_contents();
+ if (say_packet) {
+ set_has_say_packet();
+ contents_.say_packet_ = say_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.say_packet)
+}
+inline ::proto::say* packet::_internal_mutable_say_packet() {
+ if (!_internal_has_say_packet()) {
+ clear_contents();
+ set_has_say_packet();
+ contents_.say_packet_ = CreateMaybeMessage< ::proto::say >(GetArenaForAllocation());
+ }
+ return contents_.say_packet_;
+}
+inline ::proto::say* packet::mutable_say_packet() {
+ ::proto::say* _msg = _internal_mutable_say_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.say_packet)
+ return _msg;
+}
+
+// .proto.hear_player hear_player_packet = 7;
+inline bool packet::_internal_has_hear_player_packet() const {
+ return contents_case() == kHearPlayerPacket;
+}
+inline bool packet::has_hear_player_packet() const {
+ return _internal_has_hear_player_packet();
+}
+inline void packet::set_has_hear_player_packet() {
+ _oneof_case_[0] = kHearPlayerPacket;
+}
+inline void packet::clear_hear_player_packet() {
+ if (_internal_has_hear_player_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.hear_player_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::hear_player* packet::release_hear_player_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.hear_player_packet)
+ if (_internal_has_hear_player_packet()) {
+ clear_has_contents();
+ ::proto::hear_player* temp = contents_.hear_player_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.hear_player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::hear_player& packet::_internal_hear_player_packet() const {
+ return _internal_has_hear_player_packet()
+ ? *contents_.hear_player_packet_
+ : reinterpret_cast< ::proto::hear_player&>(::proto::_hear_player_default_instance_);
+}
+inline const ::proto::hear_player& packet::hear_player_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.hear_player_packet)
+ return _internal_hear_player_packet();
+}
+inline ::proto::hear_player* packet::unsafe_arena_release_hear_player_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.hear_player_packet)
+ if (_internal_has_hear_player_packet()) {
+ clear_has_contents();
+ ::proto::hear_player* temp = contents_.hear_player_packet_;
+ contents_.hear_player_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_hear_player_packet(::proto::hear_player* hear_player_packet) {
+ clear_contents();
+ if (hear_player_packet) {
+ set_has_hear_player_packet();
+ contents_.hear_player_packet_ = hear_player_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.hear_player_packet)
+}
+inline ::proto::hear_player* packet::_internal_mutable_hear_player_packet() {
+ if (!_internal_has_hear_player_packet()) {
+ clear_contents();
+ set_has_hear_player_packet();
+ contents_.hear_player_packet_ = CreateMaybeMessage< ::proto::hear_player >(GetArenaForAllocation());
+ }
+ return contents_.hear_player_packet_;
+}
+inline ::proto::hear_player* packet::mutable_hear_player_packet() {
+ ::proto::hear_player* _msg = _internal_mutable_hear_player_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.hear_player_packet)
+ return _msg;
+}
+
+// .proto.request_chunk request_chunk_packet = 8;
+inline bool packet::_internal_has_request_chunk_packet() const {
+ return contents_case() == kRequestChunkPacket;
+}
+inline bool packet::has_request_chunk_packet() const {
+ return _internal_has_request_chunk_packet();
+}
+inline void packet::set_has_request_chunk_packet() {
+ _oneof_case_[0] = kRequestChunkPacket;
+}
+inline void packet::clear_request_chunk_packet() {
+ if (_internal_has_request_chunk_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.request_chunk_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::request_chunk* packet::release_request_chunk_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.request_chunk_packet)
+ if (_internal_has_request_chunk_packet()) {
+ clear_has_contents();
+ ::proto::request_chunk* temp = contents_.request_chunk_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.request_chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::request_chunk& packet::_internal_request_chunk_packet() const {
+ return _internal_has_request_chunk_packet()
+ ? *contents_.request_chunk_packet_
+ : reinterpret_cast< ::proto::request_chunk&>(::proto::_request_chunk_default_instance_);
+}
+inline const ::proto::request_chunk& packet::request_chunk_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.request_chunk_packet)
+ return _internal_request_chunk_packet();
+}
+inline ::proto::request_chunk* packet::unsafe_arena_release_request_chunk_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.request_chunk_packet)
+ if (_internal_has_request_chunk_packet()) {
+ clear_has_contents();
+ ::proto::request_chunk* temp = contents_.request_chunk_packet_;
+ contents_.request_chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_request_chunk_packet(::proto::request_chunk* request_chunk_packet) {
+ clear_contents();
+ if (request_chunk_packet) {
+ set_has_request_chunk_packet();
+ contents_.request_chunk_packet_ = request_chunk_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.request_chunk_packet)
+}
+inline ::proto::request_chunk* packet::_internal_mutable_request_chunk_packet() {
+ if (!_internal_has_request_chunk_packet()) {
+ clear_contents();
+ set_has_request_chunk_packet();
+ contents_.request_chunk_packet_ = CreateMaybeMessage< ::proto::request_chunk >(GetArenaForAllocation());
+ }
+ return contents_.request_chunk_packet_;
+}
+inline ::proto::request_chunk* packet::mutable_request_chunk_packet() {
+ ::proto::request_chunk* _msg = _internal_mutable_request_chunk_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.request_chunk_packet)
+ return _msg;
+}
+
+// .proto.chunk chunk_packet = 9;
+inline bool packet::_internal_has_chunk_packet() const {
+ return contents_case() == kChunkPacket;
+}
+inline bool packet::has_chunk_packet() const {
+ return _internal_has_chunk_packet();
+}
+inline void packet::set_has_chunk_packet() {
+ _oneof_case_[0] = kChunkPacket;
+}
+inline void packet::clear_chunk_packet() {
+ if (_internal_has_chunk_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.chunk_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::chunk* packet::release_chunk_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.chunk_packet)
+ if (_internal_has_chunk_packet()) {
+ clear_has_contents();
+ ::proto::chunk* temp = contents_.chunk_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::chunk& packet::_internal_chunk_packet() const {
+ return _internal_has_chunk_packet()
+ ? *contents_.chunk_packet_
+ : reinterpret_cast< ::proto::chunk&>(::proto::_chunk_default_instance_);
+}
+inline const ::proto::chunk& packet::chunk_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.chunk_packet)
+ return _internal_chunk_packet();
+}
+inline ::proto::chunk* packet::unsafe_arena_release_chunk_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.chunk_packet)
+ if (_internal_has_chunk_packet()) {
+ clear_has_contents();
+ ::proto::chunk* temp = contents_.chunk_packet_;
+ contents_.chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_chunk_packet(::proto::chunk* chunk_packet) {
+ clear_contents();
+ if (chunk_packet) {
+ set_has_chunk_packet();
+ contents_.chunk_packet_ = chunk_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.chunk_packet)
+}
+inline ::proto::chunk* packet::_internal_mutable_chunk_packet() {
+ if (!_internal_has_chunk_packet()) {
+ clear_contents();
+ set_has_chunk_packet();
+ contents_.chunk_packet_ = CreateMaybeMessage< ::proto::chunk >(GetArenaForAllocation());
+ }
+ return contents_.chunk_packet_;
+}
+inline ::proto::chunk* packet::mutable_chunk_packet() {
+ ::proto::chunk* _msg = _internal_mutable_chunk_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.chunk_packet)
+ return _msg;
+}
+
+// .proto.remove_chunk remove_chunk_packet = 10;
+inline bool packet::_internal_has_remove_chunk_packet() const {
+ return contents_case() == kRemoveChunkPacket;
+}
+inline bool packet::has_remove_chunk_packet() const {
+ return _internal_has_remove_chunk_packet();
+}
+inline void packet::set_has_remove_chunk_packet() {
+ _oneof_case_[0] = kRemoveChunkPacket;
+}
+inline void packet::clear_remove_chunk_packet() {
+ if (_internal_has_remove_chunk_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_chunk_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::remove_chunk* packet::release_remove_chunk_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.remove_chunk_packet)
+ if (_internal_has_remove_chunk_packet()) {
+ clear_has_contents();
+ ::proto::remove_chunk* temp = contents_.remove_chunk_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.remove_chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::remove_chunk& packet::_internal_remove_chunk_packet() const {
+ return _internal_has_remove_chunk_packet()
+ ? *contents_.remove_chunk_packet_
+ : reinterpret_cast< ::proto::remove_chunk&>(::proto::_remove_chunk_default_instance_);
+}
+inline const ::proto::remove_chunk& packet::remove_chunk_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.remove_chunk_packet)
+ return _internal_remove_chunk_packet();
+}
+inline ::proto::remove_chunk* packet::unsafe_arena_release_remove_chunk_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.remove_chunk_packet)
+ if (_internal_has_remove_chunk_packet()) {
+ clear_has_contents();
+ ::proto::remove_chunk* temp = contents_.remove_chunk_packet_;
+ contents_.remove_chunk_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_remove_chunk_packet(::proto::remove_chunk* remove_chunk_packet) {
+ clear_contents();
+ if (remove_chunk_packet) {
+ set_has_remove_chunk_packet();
+ contents_.remove_chunk_packet_ = remove_chunk_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.remove_chunk_packet)
+}
+inline ::proto::remove_chunk* packet::_internal_mutable_remove_chunk_packet() {
+ if (!_internal_has_remove_chunk_packet()) {
+ clear_contents();
+ set_has_remove_chunk_packet();
+ contents_.remove_chunk_packet_ = CreateMaybeMessage< ::proto::remove_chunk >(GetArenaForAllocation());
+ }
+ return contents_.remove_chunk_packet_;
+}
+inline ::proto::remove_chunk* packet::mutable_remove_chunk_packet() {
+ ::proto::remove_chunk* _msg = _internal_mutable_remove_chunk_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.remove_chunk_packet)
+ return _msg;
+}
+
+// .proto.add_block add_block_packet = 11;
+inline bool packet::_internal_has_add_block_packet() const {
+ return contents_case() == kAddBlockPacket;
+}
+inline bool packet::has_add_block_packet() const {
+ return _internal_has_add_block_packet();
+}
+inline void packet::set_has_add_block_packet() {
+ _oneof_case_[0] = kAddBlockPacket;
+}
+inline void packet::clear_add_block_packet() {
+ if (_internal_has_add_block_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.add_block_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::add_block* packet::release_add_block_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.add_block_packet)
+ if (_internal_has_add_block_packet()) {
+ clear_has_contents();
+ ::proto::add_block* temp = contents_.add_block_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.add_block_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::add_block& packet::_internal_add_block_packet() const {
+ return _internal_has_add_block_packet()
+ ? *contents_.add_block_packet_
+ : reinterpret_cast< ::proto::add_block&>(::proto::_add_block_default_instance_);
+}
+inline const ::proto::add_block& packet::add_block_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.add_block_packet)
+ return _internal_add_block_packet();
+}
+inline ::proto::add_block* packet::unsafe_arena_release_add_block_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.add_block_packet)
+ if (_internal_has_add_block_packet()) {
+ clear_has_contents();
+ ::proto::add_block* temp = contents_.add_block_packet_;
+ contents_.add_block_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_add_block_packet(::proto::add_block* add_block_packet) {
+ clear_contents();
+ if (add_block_packet) {
+ set_has_add_block_packet();
+ contents_.add_block_packet_ = add_block_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.add_block_packet)
+}
+inline ::proto::add_block* packet::_internal_mutable_add_block_packet() {
+ if (!_internal_has_add_block_packet()) {
+ clear_contents();
+ set_has_add_block_packet();
+ contents_.add_block_packet_ = CreateMaybeMessage< ::proto::add_block >(GetArenaForAllocation());
+ }
+ return contents_.add_block_packet_;
+}
+inline ::proto::add_block* packet::mutable_add_block_packet() {
+ ::proto::add_block* _msg = _internal_mutable_add_block_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.add_block_packet)
+ return _msg;
+}
+
+// .proto.remove_block remove_block_packet = 12;
+inline bool packet::_internal_has_remove_block_packet() const {
+ return contents_case() == kRemoveBlockPacket;
+}
+inline bool packet::has_remove_block_packet() const {
+ return _internal_has_remove_block_packet();
+}
+inline void packet::set_has_remove_block_packet() {
+ _oneof_case_[0] = kRemoveBlockPacket;
+}
+inline void packet::clear_remove_block_packet() {
+ if (_internal_has_remove_block_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.remove_block_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::remove_block* packet::release_remove_block_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.remove_block_packet)
+ if (_internal_has_remove_block_packet()) {
+ clear_has_contents();
+ ::proto::remove_block* temp = contents_.remove_block_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.remove_block_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::remove_block& packet::_internal_remove_block_packet() const {
+ return _internal_has_remove_block_packet()
+ ? *contents_.remove_block_packet_
+ : reinterpret_cast< ::proto::remove_block&>(::proto::_remove_block_default_instance_);
+}
+inline const ::proto::remove_block& packet::remove_block_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.remove_block_packet)
+ return _internal_remove_block_packet();
+}
+inline ::proto::remove_block* packet::unsafe_arena_release_remove_block_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.remove_block_packet)
+ if (_internal_has_remove_block_packet()) {
+ clear_has_contents();
+ ::proto::remove_block* temp = contents_.remove_block_packet_;
+ contents_.remove_block_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_remove_block_packet(::proto::remove_block* remove_block_packet) {
+ clear_contents();
+ if (remove_block_packet) {
+ set_has_remove_block_packet();
+ contents_.remove_block_packet_ = remove_block_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.remove_block_packet)
+}
+inline ::proto::remove_block* packet::_internal_mutable_remove_block_packet() {
+ if (!_internal_has_remove_block_packet()) {
+ clear_contents();
+ set_has_remove_block_packet();
+ contents_.remove_block_packet_ = CreateMaybeMessage< ::proto::remove_block >(GetArenaForAllocation());
+ }
+ return contents_.remove_block_packet_;
+}
+inline ::proto::remove_block* packet::mutable_remove_block_packet() {
+ ::proto::remove_block* _msg = _internal_mutable_remove_block_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.remove_block_packet)
+ return _msg;
+}
+
+// .proto.server_message server_message_packet = 13;
+inline bool packet::_internal_has_server_message_packet() const {
+ return contents_case() == kServerMessagePacket;
+}
+inline bool packet::has_server_message_packet() const {
+ return _internal_has_server_message_packet();
+}
+inline void packet::set_has_server_message_packet() {
+ _oneof_case_[0] = kServerMessagePacket;
+}
+inline void packet::clear_server_message_packet() {
+ if (_internal_has_server_message_packet()) {
+ if (GetArenaForAllocation() == nullptr) {
+ delete contents_.server_message_packet_;
+ }
+ clear_has_contents();
+ }
+}
+inline ::proto::server_message* packet::release_server_message_packet() {
+ // @@protoc_insertion_point(field_release:proto.packet.server_message_packet)
+ if (_internal_has_server_message_packet()) {
+ clear_has_contents();
+ ::proto::server_message* temp = contents_.server_message_packet_;
+ if (GetArenaForAllocation() != nullptr) {
+ temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+ }
+ contents_.server_message_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline const ::proto::server_message& packet::_internal_server_message_packet() const {
+ return _internal_has_server_message_packet()
+ ? *contents_.server_message_packet_
+ : reinterpret_cast< ::proto::server_message&>(::proto::_server_message_default_instance_);
+}
+inline const ::proto::server_message& packet::server_message_packet() const {
+ // @@protoc_insertion_point(field_get:proto.packet.server_message_packet)
+ return _internal_server_message_packet();
+}
+inline ::proto::server_message* packet::unsafe_arena_release_server_message_packet() {
+ // @@protoc_insertion_point(field_unsafe_arena_release:proto.packet.server_message_packet)
+ if (_internal_has_server_message_packet()) {
+ clear_has_contents();
+ ::proto::server_message* temp = contents_.server_message_packet_;
+ contents_.server_message_packet_ = nullptr;
+ return temp;
+ } else {
+ return nullptr;
+ }
+}
+inline void packet::unsafe_arena_set_allocated_server_message_packet(::proto::server_message* server_message_packet) {
+ clear_contents();
+ if (server_message_packet) {
+ set_has_server_message_packet();
+ contents_.server_message_packet_ = server_message_packet;
+ }
+ // @@protoc_insertion_point(field_unsafe_arena_set_allocated:proto.packet.server_message_packet)
+}
+inline ::proto::server_message* packet::_internal_mutable_server_message_packet() {
+ if (!_internal_has_server_message_packet()) {
+ clear_contents();
+ set_has_server_message_packet();
+ contents_.server_message_packet_ = CreateMaybeMessage< ::proto::server_message >(GetArenaForAllocation());
+ }
+ return contents_.server_message_packet_;
+}
+inline ::proto::server_message* packet::mutable_server_message_packet() {
+ ::proto::server_message* _msg = _internal_mutable_server_message_packet();
+ // @@protoc_insertion_point(field_mutable:proto.packet.server_message_packet)
+ return _msg;
+}
+
+inline bool packet::has_contents() const {
+ return contents_case() != CONTENTS_NOT_SET;
+}
+inline void packet::clear_has_contents() {
+ _oneof_case_[0] = CONTENTS_NOT_SET;
+}
+inline packet::ContentsCase packet::contents_case() const {
+ return packet::ContentsCase(_oneof_case_[0]);
+}
+#ifdef __GNUC__
+ #pragma GCC diagnostic pop
+#endif // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+} // namespace proto
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_net_2eproto
diff --git a/src/shared/net/lib/protobuf/net.proto b/src/shared/net/lib/protobuf/net.proto
new file mode 100644
index 0000000..79d58e7
--- /dev/null
+++ b/src/shared/net/lib/protobuf/net.proto
@@ -0,0 +1,123 @@
+syntax = "proto3";
+
+package proto;
+
+// STRUCTS
+message angles {
+ float pitch = 1;
+ float yaw = 2;
+}
+
+message coords {
+ int32 x = 1;
+ int32 z = 2;
+}
+
+message vec3 {
+ float x = 1;
+ float y = 2;
+ float z = 3;
+}
+
+message ivec3 {
+ int32 x = 1;
+ int32 y = 2;
+ int32 z = 3;
+}
+
+message player {
+ uint32 index = 1;
+ uint32 commands = 2;
+
+ coords chunk_pos = 3;
+ vec3 local_pos = 4;
+
+ angles viewangles = 5;
+ vec3 velocity = 6;
+}
+// END OF STRUCTS
+
+// PACKETS
+message auth {
+ string username = 1;
+ string password = 2;
+}
+
+message init {
+ uint64 seed = 1;
+ int32 draw_distance = 2;
+ player localplayer = 3;
+}
+
+message move {
+ uint32 commands = 1;
+ angles viewangles = 2;
+}
+
+message remove_player {
+ uint32 index = 1;
+}
+
+message say {
+ string text = 1;
+}
+
+message hear_player {
+ uint32 index = 1;
+ string text = 2;
+}
+
+message request_chunk {
+ coords chunk_pos = 1;
+}
+
+message remove_chunk {
+ coords chunk_pos = 1;
+}
+
+message chunk {
+ coords chunk_pos = 1;
+ // There is no uint8, so we have to pack four blocks into each uint32.
+ repeated uint32 blocks = 2 [packed = true];
+}
+
+message add_block {
+ coords chunk_pos = 1;
+ ivec3 block_pos = 2;
+ // A bit inefficient as we only need 8 bits. We could use the rest for other
+ // stuff down the road.
+ uint32 block = 3;
+}
+
+message remove_block {
+ coords chunk_pos = 1;
+ ivec3 block_pos = 2;
+}
+
+message server_message {
+ string message = 1;
+ bool fatal = 2;
+}
+// END OF PACKETS
+
+// Actual thing we read.
+message packet {
+
+oneof contents {
+ auth auth_packet = 1;
+ init init_packet = 2;
+ move move_packet = 3;
+ player player_packet = 4;
+ remove_player remove_player_packet = 5;
+ say say_packet = 6;
+ hear_player hear_player_packet = 7;
+ request_chunk request_chunk_packet = 8;
+ chunk chunk_packet = 9;
+ remove_chunk remove_chunk_packet = 10;
+ add_block add_block_packet = 11;
+ remove_block remove_block_packet = 12;
+ server_message server_message_packet = 13;
+}
+
+}
+
diff --git a/src/shared/net/net.cc b/src/shared/net/net.cc
new file mode 100644
index 0000000..dc78261
--- /dev/null
+++ b/src/shared/net/net.cc
@@ -0,0 +1,138 @@
+#include "net.hh"
+
+namespace shared {
+namespace net {
+
+// Some calls use errno, some use strerr.
+std::string get_net_error(const int code) noexcept {
+ return make_string_lower(std::string(gai_strerror(code)));
+}
+
+std::string get_errno_error() noexcept {
+ return make_string_lower(std::string(strerror(errno)));
+}
+
+std::shared_ptr<addrinfo> get_addr_info(const std::string_view address,
+ const std::string_view port,
+ const addrinfo* const hints) {
+ addrinfo* info;
+ if (int status = getaddrinfo(address.data(), port.data(), hints, &info)) {
+ throw std::runtime_error(get_net_error(status));
+ }
+ return std::shared_ptr<addrinfo>{info, [](auto p) { freeaddrinfo(p); }};
+}
+
+int make_socket(const addrinfo* const info) {
+ int sock = socket(info->ai_family, info->ai_socktype, info->ai_protocol);
+ if (sock == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ int enable = 1;
+ setsockopt(sock, SOL_SOCKET, SO_REUSEPORT, &enable, sizeof(int));
+ setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(int));
+ return sock;
+}
+
+void bind_socket(const int sock, const addrinfo* const info) {
+ // Bind to the first we can, otherwise throw.
+ for (const addrinfo* i = info; i; i = i->ai_next) {
+ if (bind(sock, info->ai_addr, info->ai_addrlen) != -1) {
+ return;
+ }
+ }
+ throw std::runtime_error(get_errno_error());
+}
+
+void connect_socket(const int sock, const addrinfo* const info) {
+ if (connect(sock, info->ai_addr, info->ai_addrlen) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+}
+
+void nonblock_socket(const int sock) {
+ if (fcntl(sock, F_SETFL, O_NONBLOCK) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+}
+
+void* get_info_address(sockaddr& info) noexcept {
+ if (info.sa_family == AF_INET) {
+ return &(reinterpret_cast<sockaddr_in*>(&info)->sin_addr);
+ }
+ return &(reinterpret_cast<sockaddr_in6*>(&info)->sin6_addr);
+}
+
+void listen_socket(const int sock) {
+ fcntl(sock, F_SETFL, O_NONBLOCK);
+ if (listen(sock, SOMAXCONN) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+}
+
+// Returns std::nullopt on failure! We lose the ability to throw here.
+std::optional<accept_ret> get_accept(const int sock) {
+ accept_ret info;
+ socklen_t size = sizeof(info.storage);
+ info.socket =
+ accept(sock, reinterpret_cast<sockaddr*>(&info.storage), &size);
+ if (info.socket == -1) {
+ return std::nullopt;
+ }
+ return info;
+}
+
+void close_socket(const int sock) {
+ if (close(sock) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+}
+
+// Returns the size of the receive buffer.
+// For reliable, returns size of the stream (thanks [][][]).
+// For unreliable, returns size of the next datagram available for reading.
+std::size_t get_backlog_size(const int sock) {
+ size_t result = 0;
+ if (ioctl(sock, FIONREAD, &result) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ return result;
+}
+
+std::string get_socket_host_address(const int sock) {
+ sockaddr_in sin;
+ socklen_t size = sizeof(sin);
+ if (getsockname(sock, reinterpret_cast<sockaddr*>(&sin), &size) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ return std::string(inet_ntoa(sin.sin_addr));
+}
+
+std::string get_socket_host_port(const int sock) {
+ sockaddr_in sin;
+ socklen_t size = sizeof(sin);
+ if (getsockname(sock, reinterpret_cast<sockaddr*>(&sin), &size) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ return std::to_string(ntohs(sin.sin_port));
+}
+
+std::string get_socket_peer_address(const int sock) {
+ sockaddr_in sin;
+ socklen_t size = sizeof(sin);
+ if (getpeername(sock, reinterpret_cast<sockaddr*>(&sin), &size) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ return std::string(inet_ntoa(sin.sin_addr));
+}
+
+std::string get_socket_peer_port(const int sock) {
+ sockaddr_in sin;
+ socklen_t size = sizeof(sin);
+ if (getpeername(sock, reinterpret_cast<sockaddr*>(&sin), &size) == -1) {
+ throw std::runtime_error(get_errno_error());
+ }
+ return std::to_string(ntohs(sin.sin_port));
+}
+
+} // namespace net
+} // namespace shared
diff --git a/src/shared/net/net.hh b/src/shared/net/net.hh
new file mode 100644
index 0000000..2603398
--- /dev/null
+++ b/src/shared/net/net.hh
@@ -0,0 +1,56 @@
+#ifndef SHARED_NET_NET_HH_
+#define SHARED_NET_NET_HH_
+
+#include <arpa/inet.h>
+#include <concepts>
+#include <cstdint>
+#include <cstring>
+#include <errno.h>
+#include <fcntl.h>
+#include <memory>
+#include <netdb.h>
+#include <netinet/in.h>
+#include <optional>
+#include <stdexcept>
+#include <string.h>
+#include <string>
+#include <string_view>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <type_traits>
+#include <unistd.h>
+
+#include "shared/shared.hh"
+
+namespace shared {
+namespace net {
+
+std::string get_net_error(const int code) noexcept;
+std::string get_errno_error() noexcept;
+std::shared_ptr<addrinfo> get_addr_info(const std::string_view address,
+ const std::string_view port,
+ const addrinfo* const hints);
+int make_socket(const addrinfo* const info);
+void bind_socket(const int socket, const addrinfo* const info);
+void connect_socket(const int socket, const addrinfo* const info);
+void nonblock_socket(const int sock);
+void listen_socket(const int socket);
+void* get_info_address(sockaddr& info) noexcept;
+void close_socket(const int sock);
+// Return socket and the sockaddr_storage we get from an accept call.
+struct accept_ret {
+ sockaddr_storage storage;
+ int socket;
+};
+std::optional<accept_ret> get_accept(const int socket);
+std::size_t get_backlog_size(const int sock);
+std::string get_socket_host_address(const int sock);
+std::string get_socket_host_port(const int sock);
+std::string get_socket_peer_address(const int sock);
+std::string get_socket_peer_port(const int sock);
+
+} // namespace net
+} // namespace shared
+
+#endif
diff --git a/src/shared/net/proto.cc b/src/shared/net/proto.cc
new file mode 100644
index 0000000..1c954b1
--- /dev/null
+++ b/src/shared/net/proto.cc
@@ -0,0 +1,55 @@
+#include "shared/net/proto.hh"
+
+namespace shared {
+namespace net {
+
+shared::player get_player(const proto::player& packet) noexcept {
+ return shared::player{
+ .index = packet.index(),
+ .commands = packet.commands(),
+ .chunk_pos = {packet.chunk_pos().x(), packet.chunk_pos().z()},
+ .local_pos = {packet.local_pos().x(), packet.local_pos().y(),
+ packet.local_pos().z()},
+ .viewangles = {packet.viewangles().pitch(), packet.viewangles().yaw()},
+ .velocity = {packet.velocity().x(), packet.velocity().y(),
+ packet.velocity().z()},
+ };
+}
+
+void set_angles(proto::angles& proto_angles,
+ const shared::math::angles& angles) noexcept {
+ proto_angles.set_pitch(angles.pitch);
+ proto_angles.set_yaw(angles.yaw);
+}
+
+void set_coords(proto::coords& proto_coords,
+ const shared::math::coords& coords) noexcept {
+ proto_coords.set_x(coords.x);
+ proto_coords.set_z(coords.z);
+}
+
+void set_vec3(proto::vec3& proto_vec3, const glm::vec3& vec3) noexcept {
+ proto_vec3.set_x(vec3.x);
+ proto_vec3.set_y(vec3.y);
+ proto_vec3.set_z(vec3.z);
+}
+
+void set_ivec3(proto::ivec3& proto_ivec3, const glm::ivec3& ivec3) noexcept {
+ proto_ivec3.set_x(ivec3.x);
+ proto_ivec3.set_y(ivec3.y);
+ proto_ivec3.set_z(ivec3.z);
+}
+
+void set_player(proto::player& proto_player,
+ const shared::player& player) noexcept {
+ proto_player.set_index(player.index);
+ proto_player.set_commands(player.commands);
+ set_coords(*proto_player.mutable_chunk_pos(), player.chunk_pos);
+ set_vec3(*proto_player.mutable_local_pos(), player.local_pos);
+ set_angles(*proto_player.mutable_viewangles(), player.viewangles);
+ set_vec3(*proto_player.mutable_velocity(), player.velocity);
+}
+
+} // namespace net
+
+} // namespace shared
diff --git a/src/shared/net/proto.hh b/src/shared/net/proto.hh
new file mode 100644
index 0000000..93bb005
--- /dev/null
+++ b/src/shared/net/proto.hh
@@ -0,0 +1,28 @@
+#ifndef SHARED_NET_PROTO_HH_
+#define SHARED_NET_PROTO_HH_
+
+#include "shared/math.hh"
+#include "shared/player.hh"
+
+#undef Status // Protobuf doesn't like xlib apparently.
+#include "shared/net/lib/protobuf/net.pb.h"
+
+// TODO packet struct parsing packet helper functions
+namespace shared {
+namespace net {
+
+shared::player get_player(const proto::player& packet) noexcept;
+
+void set_angles(proto::angles& proto_angles,
+ const shared::math::angles& angles) noexcept;
+void set_coords(proto::coords& proto_coords,
+ const shared::math::coords& coords) noexcept;
+void set_vec3(proto::vec3& proto_vec3, const glm::vec3& vec3) noexcept;
+void set_ivec3(proto::ivec3& proto_ivec3, const glm::ivec3& ivec3) noexcept;
+void set_player(proto::player& proto_player,
+ const shared::player& player) noexcept;
+
+} // namespace net
+} // namespace shared
+
+#endif
diff --git a/src/shared/player.cc b/src/shared/player.cc
new file mode 100644
index 0000000..55542ca
--- /dev/null
+++ b/src/shared/player.cc
@@ -0,0 +1 @@
+#include "player.hh"
diff --git a/src/shared/player.hh b/src/shared/player.hh
new file mode 100644
index 0000000..5929c5b
--- /dev/null
+++ b/src/shared/player.hh
@@ -0,0 +1,46 @@
+#ifndef SHARED_PLAYER_HH_
+#define SHARED_PLAYER_HH_
+
+#include <cstdint>
+
+#include <glm/glm.hpp>
+
+#include "shared/math.hh"
+
+namespace shared {
+
+// Anything here goes over the wire.
+struct player {
+public:
+ using index_t = std::uint32_t;
+
+ static constexpr float HEIGHT = 1.9f;
+ static constexpr float EYE_HEIGHT = HEIGHT * 0.8f;
+ static constexpr float HALFWIDTH = 0.25f;
+
+public:
+ std::uint32_t index = 0;
+ std::uint32_t commands = 0;
+
+ shared::math::coords chunk_pos = {};
+ glm::vec3 local_pos = {};
+
+ shared::math::angles viewangles = {};
+ glm::vec3 velocity = {};
+
+public:
+ enum mask : decltype(commands) {
+ forward = 1 << 0,
+ left = 1 << 1,
+ backward = 1 << 2,
+ right = 1 << 3,
+ jump = 1 << 4,
+ crouch = 1 << 5,
+ sprint = 1 << 6,
+ attack = 1 << 7
+ };
+};
+
+} // namespace shared
+
+#endif
diff --git a/src/shared/shared.cc b/src/shared/shared.cc
new file mode 100644
index 0000000..55ccf1f
--- /dev/null
+++ b/src/shared/shared.cc
@@ -0,0 +1,57 @@
+#include "shared.hh"
+
+namespace shared {
+
+std::string make_string_lower(std::string str) noexcept {
+ std::ranges::transform(str.begin(), str.end(), str.begin(),
+ [](const auto c) { return std::tolower(c); });
+ return str;
+}
+
+std::string read_file(const std::string& path) {
+ std::ifstream input(path);
+ if (!input.is_open()) {
+ throw std::runtime_error("failed to read file: " + path);
+ }
+ return std::string{std::istreambuf_iterator<char>(input),
+ std::istreambuf_iterator<char>()};
+}
+
+std::ofstream open_file(const std::string& dir,
+ const std::ios_base::openmode mode) {
+ std::ofstream ret(dir, mode);
+ if (!ret.is_open()) {
+ throw std::runtime_error("failed to write file: " + dir);
+ }
+ return ret;
+}
+
+void compress_string(std::string& str) noexcept {
+ std::stringstream input(str);
+
+ boost::iostreams::filtering_streambuf<boost::iostreams::input> out;
+ out.push(boost::iostreams::gzip_compressor(boost::iostreams::gzip_params(
+ boost::iostreams::gzip::best_compression)));
+ out.push(input);
+
+ std::stringstream result;
+ boost::iostreams::copy(out, result);
+
+ str = result.str();
+}
+
+void decompress_string(std::string& str) noexcept {
+ std::stringstream input;
+ input << str;
+
+ boost::iostreams::filtering_streambuf<boost::iostreams::input> in;
+ in.push(boost::iostreams::gzip_decompressor());
+ in.push(input);
+
+ std::stringstream result;
+ boost::iostreams::copy(in, result);
+
+ str = result.str();
+}
+
+} // namespace shared
diff --git a/src/shared/shared.hh b/src/shared/shared.hh
new file mode 100644
index 0000000..2d64814
--- /dev/null
+++ b/src/shared/shared.hh
@@ -0,0 +1,120 @@
+#ifndef SHARED_SHARED_HH_
+#define SHARED_SHARED_HH_
+
+#include <algorithm>
+#include <atomic>
+#include <chrono>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <mutex>
+#include <ranges>
+#include <string>
+
+#include <boost/iostreams/copy.hpp>
+#include <boost/iostreams/filter/gzip.hpp>
+#include <boost/iostreams/filtering_streambuf.hpp>
+
+#include "shared/math.hh"
+
+// Tiny thread safe printing.
+namespace shared {
+
+std::string make_string_lower(std::string str) noexcept;
+std::string read_file(const std::string& path);
+void compress_string(std::string& str) noexcept;
+void decompress_string(std::string& str) noexcept;
+std::ofstream open_file(const std::string& dir,
+ const std::ios_base::openmode mode = std::ios::trunc);
+
+constexpr unsigned long MAX_SAY_LENGTH = 32ul;
+constexpr unsigned long MAX_USER_PASS_LENGTH = 64;
+
+class print {
+private:
+ static inline std::mutex lock;
+
+public:
+ enum class colour {
+ black = 30,
+ red = 31,
+ green = 32,
+ yellow = 33,
+ blue = 34,
+ magenta = 35,
+ cyan = 36,
+ white = 37,
+ none = 39,
+ grey = 90,
+ bright_red = 91,
+ bright_green = 92,
+ bright_yellow = 93,
+ bright_blue = 94,
+ bright_magenta = 95,
+ bright_cyan = 96,
+ bright_white = 97
+ };
+
+private:
+ static void print_message(const std::string_view message,
+ const bool print_time,
+ const std::string_view colour,
+ const bool cerr = false) noexcept {
+ const std::lock_guard<std::mutex> guard(lock);
+
+ if (print_time) {
+ const auto epoch = std::time(nullptr);
+ struct tm* local = localtime(&epoch);
+ std::cout << std::put_time(local, "[%F %T] ");
+ }
+ static std::string none = make_colour(colour::none);
+
+ if (cerr) {
+ std::cerr << colour << message << none;
+ return;
+ }
+
+ std::cout << colour << message << none;
+ }
+ static std::string make_colour(const colour clr) noexcept {
+ return {"\033[" + std::to_string(static_cast<int>(clr)) + "m"};
+ }
+
+public:
+ print() noexcept = delete;
+ static void message(const std::string_view msg,
+ const bool print_time = true) noexcept {
+ static const std::string grey = make_colour(colour::white);
+ print_message(msg, print_time, grey);
+ }
+ static void notify(const std::string_view msg,
+ const bool print_time = true) noexcept {
+ static const std::string cyan = make_colour(colour::cyan);
+ print_message(msg, print_time, cyan);
+ }
+ static void warn(const std::string_view msg,
+ const bool print_time = true) noexcept {
+ static const std::string b_yellow = make_colour(colour::bright_yellow);
+ print_message(msg, print_time, b_yellow);
+ }
+ static void fault(const std::string_view msg,
+ const bool print_time = true) noexcept {
+ static const std::string bright_red = make_colour(colour::bright_red);
+ print_message(msg, print_time, bright_red, true);
+ }
+ static void debug(const std::string_view msg,
+ const bool print_time = true) noexcept {
+ static const std::string magenta = make_colour(colour::magenta);
+ print_message(msg, print_time, magenta, true);
+ }
+ static void custom(const std::string_view msg, const enum colour colour,
+ const bool print_time = true) noexcept {
+ print_message(msg, print_time, make_colour(colour));
+ }
+};
+
+inline std::atomic<bool> should_exit = false;
+
+}; // namespace shared
+
+#endif
diff --git a/src/shared/world.cc b/src/shared/world.cc
new file mode 100644
index 0000000..d56b7a8
--- /dev/null
+++ b/src/shared/world.cc
@@ -0,0 +1,932 @@
+#include "shared/world.hh"
+
+namespace shared {
+namespace world {
+
+// Because C++ doesn't allow us to iterate over an enum,
+// (or get the size of an enum, or get the name of an enum, etc) biomes defined
+// in the chunk::biome enum class have to be readded here. Alternatively we
+// could use some compiler hack library.
+constexpr std::array<enum shared::world::chunk::biome, 7> biome_enums{
+ shared::world::chunk::biome::alpine, shared::world::chunk::biome::tundra,
+ shared::world::chunk::biome::forest, shared::world::chunk::biome::plains,
+ shared::world::chunk::biome::ocean, shared::world::chunk::biome::islands,
+ shared::world::chunk::biome::desert};
+
+constexpr long get_biome_index(const enum shared::world::chunk::biome biome) noexcept {
+ return std::distance(std::begin(biome_enums),
+ std::ranges::find(biome_enums, biome));
+}
+
+chunk::block_array
+chunk::make_blocks_from_chunk(const proto::chunk& chunk) noexcept {
+ chunk::block_array blocks;
+
+ for (int i = 0; i < chunk.blocks_size(); ++i) {
+ const std::uint32_t packed_blocks = chunk.blocks(i);
+ for (int j = 0; j < 4; ++j) {
+ blocks[static_cast<unsigned>(i * 4 + j)] =
+ static_cast<enum block::type>(
+ static_cast<std::uint8_t>(packed_blocks >> j * 8));
+ }
+ }
+
+ return blocks;
+}
+
+// Returns a deterministic random number based on the args.
+static unsigned long make_prandom(const uint64_t seed,
+ const shared::math::coords& coords) noexcept {
+ const auto ulx = static_cast<unsigned long>(coords.x);
+ const auto ulz = static_cast<unsigned long>(coords.z);
+ return std::ranlux48{std::ranlux48{std::ranlux48{seed}() + ulx}() + ulz}();
+}
+
+// Returns a pseduorandom gradient vector.
+static glm::vec2 make_gvect(const std::uint64_t& seed,
+ const shared::math::coords& coords) noexcept {
+ const unsigned long pseudo = make_prandom(seed, coords);
+ // Return a vector based on the first four bits of this random number.
+ // This vector can point in dirs (x with a + on it) with range [-1, 1].
+ const float v1 = ((pseudo & 0b00001111) / 7.5f) - 1.0f;
+ const float v2 = (((pseudo & 0b11110000) >> 4) / 7.5f) - 1.0f;
+ return {v1, v2};
+}
+
+// Returns a distance vector between a vector and a grid position in a chunk.
+static glm::vec2 make_dvect(const glm::vec2 v, const unsigned int x,
+ const unsigned int z, const int width) noexcept {
+ const auto div = static_cast<float>(width - 1);
+ const float v1 = v.x - (static_cast<float>(x) / div);
+ const float v2 = v.y - (static_cast<float>(z) / div);
+ return {v1, v2};
+}
+
+static float fade(const float v) noexcept {
+ return v * v * v * (v * (v * 6 - 15) + 10);
+}
+
+static std::int32_t reflect_outer(const std::int32_t& n,
+ const int WIDTH = chunk::WIDTH) noexcept {
+ return n < 0 ? ((n - (WIDTH - 1)) / WIDTH) : n / WIDTH;
+}
+
+static std::int32_t reflect_inner(const std::int32_t& n,
+ const int WIDTH = chunk::WIDTH) noexcept {
+ return ((n % WIDTH) + WIDTH) % WIDTH;
+}
+
+// Moves perlin noise values from the range of [-1.0f, 1.0f] to [0.0f, 1.0f].
+// It's more useful to have a perlin layer add nothing at its absolute lowest,
+// then it is for a perlin layer to potentially remove 1.0f at its lowest.
+static float normalise_perlin(const float perlin) noexcept {
+ return 0.5f * (perlin + 1.0f);
+}
+
+using chunk_array = std::array<std::array<float, chunk::WIDTH>, chunk::WIDTH>;
+using chunk_array_map =
+ std::unordered_map<shared::math::coords, chunk_array,
+ decltype(&chunk::hash), decltype(&chunk::equal)>;
+
+// 2D Perlin noise, in which we:
+// 1. Define corners of a square as vectors, in this case using 0 or 1.
+// 2. Assign pseudorandom normalised gradient vectors to each corner vector.
+// 3. Create and iterate through a 2d array, where we:
+// 3.1: Generate distance vectors from each corner vector to the cell.
+// 3.2: Dot our gradient vectors and distance vectors respectively.
+// 3.3: Lerp our bottom and top dot product values by a fade function and x.
+// 3.4: Lerp (3.3) via fade function and z. This is the cell result.
+// There is an additional step where we make use of "scale" (any s* var). This
+// involves moving the requested chunk into a potentially different chunk, and
+// accessing a greater level of detail. It's just zoom and enhance.
+static chunk_array make_2d_perlin_array(const std::uint64_t& seed,
+ const shared::math::coords& pos,
+ const int scale) noexcept {
+ constexpr glm::vec2 tr = {1.0f, 1.0f}; // (1)
+ constexpr glm::vec2 tl = {0.0f, 1.0f};
+ constexpr glm::vec2 bl = {0.0f, 0.0f};
+ constexpr glm::vec2 br = {1.0f, 0.0f};
+
+ const int scx = reflect_outer(pos.x, scale);
+ const int scz = reflect_outer(pos.z, scale);
+ const int swidth = chunk::WIDTH * scale;
+
+ // clang-format off
+ const glm::vec2 tr_g = glm::normalize(make_gvect(seed, shared::math::coords{scx, scz})); // (2)
+ const glm::vec2 tl_g = glm::normalize(make_gvect(seed, shared::math::coords{scx - 1, scz}));
+ const glm::vec2 bl_g = glm::normalize(make_gvect(seed, shared::math::coords{scx - 1, scz - 1}));
+ const glm::vec2 br_g = glm::normalize(make_gvect(seed, shared::math::coords{scx, scz - 1}));
+ // clang-format on
+
+ chunk_array perlin; // (3)
+
+ const int x_offset = reflect_inner(pos.x, scale) * chunk::WIDTH;
+ const int z_offset = reflect_inner(pos.z, scale) * chunk::WIDTH;
+ for (auto x = 0u; x < chunk::WIDTH; ++x) {
+ const unsigned sx = x + static_cast<unsigned>(x_offset);
+
+ for (auto z = 0u; z < chunk::WIDTH; ++z) {
+ const unsigned sz = z + static_cast<unsigned>(z_offset);
+
+ const glm::vec2 tr_d = make_dvect(tr, sx, sz, swidth); // (3.1)
+ const glm::vec2 tl_d = make_dvect(tl, sx, sz, swidth);
+ const glm::vec2 bl_d = make_dvect(bl, sx, sz, swidth);
+ const glm::vec2 br_d = make_dvect(br, sx, sz, swidth);
+
+ const float tr_dp = glm::dot(tr_g, tr_d); // (3.2)
+ const float tl_dp = glm::dot(tl_g, tl_d);
+ const float bl_dp = glm::dot(bl_g, bl_d);
+ const float br_dp = glm::dot(br_g, br_d);
+
+ const float fswidth = static_cast<float>(swidth - 1);
+ const float fracx = (static_cast<float>(sx) + 0.5f) / fswidth;
+ const float fracz = (static_cast<float>(sz) + 0.5f) / fswidth;
+ const float tl_tr = std::lerp(tl_dp, tr_dp, fade(fracx)); // (3.3)
+ const float bl_br = std::lerp(bl_dp, br_dp, fade(fracx));
+
+ const float result = std::lerp(tl_tr, bl_br, fade(1.0f - fracz));
+
+ perlin[x][z] = normalise_perlin(result); // (3.4)
+ }
+ }
+
+ return perlin;
+}
+
+using biome_array = std::array<
+ std::array<std::array<float, std::size(biome_enums)>, chunk::WIDTH>,
+ chunk::WIDTH>;
+using biome_array_map =
+ std::unordered_map<shared::math::coords, biome_array,
+ decltype(&chunk::hash), decltype(&chunk::equal)>;
+// A 2d_biome_array is a 2d array containing a [0.0f-1.0f] value, tied to a
+// biome, representing the weight the biomes have on each column in the world.
+// Naturally each column should take that % of each biome's ruleset during
+// worldgen, resuling in an amount of rules that adds up to 100%.
+
+// Unfortunately this is a bit of a hell function because it is full of very
+// specific operations that can't be reasonably separated without decreasing
+// random number generation complexity or exposing a ton of random static
+// functions that will never be used outside of this.
+// Basically I am trying to minimise this bad code.
+static biome_array make_2d_biome_array(const std::uint64_t& seed,
+ const shared::math::coords& coords,
+ const int scale) noexcept {
+
+ // Decreasing NUM_POINTS to the smallest meaningful value of 1 while
+ // simultaneously decreasing our scale results in FAR lower computational
+ // cost while achieving approximately the same result. This is because we
+ // only have to generate 9 random numbers, as opposed to n * 9, which is a
+ // performance KILLER.
+ constexpr int NUM_POINTS = 1;
+
+ struct point {
+ glm::vec2 pos;
+ enum chunk::biome biome;
+ };
+ using point_array = std::array<struct point, NUM_POINTS>;
+ const auto make_points =
+ [&seed](const shared::math::coords& c) -> point_array {
+ constexpr int BITS_PER_FLOAT = 48 / 2; // ranlux 48 / 2
+ constexpr int MASK = ((2 << BITS_PER_FLOAT) - 1);
+ static_assert(BITS_PER_FLOAT * 2 * NUM_POINTS <= 48);
+
+ const unsigned long prand = make_prandom(seed, c);
+ std::uniform_int_distribution<> uniform{0, std::size(biome_enums) - 1};
+ std::ranlux48 generator{prand};
+
+ point_array points;
+ std::ranges::generate(points, [&, n = 0]() mutable -> point {
+ const int x = (prand >> ((n + 1) * BITS_PER_FLOAT)) & MASK;
+ const int y = (prand >> ((n)*BITS_PER_FLOAT)) & MASK;
+ const glm::vec2 pos = glm::vec2{x, y} / static_cast<float>(MASK);
+ const auto biome = static_cast<chunk::biome>(uniform(generator));
+ ++n;
+ return {pos, biome};
+ });
+ return points;
+ };
+
+ const shared::math::coords scaled_coords{reflect_outer(coords.x, scale),
+ reflect_outer(coords.z, scale)};
+
+ using point_2d_array = std::array<std::array<point_array, 3>, 3>;
+ const point_2d_array point_arrays = [&]() -> point_2d_array {
+ point_2d_array point_arrays;
+ for (int x = -1; x <= 1; ++x) {
+ for (int z = -1; z <= 1; ++z) {
+ const auto offset_coords =
+ scaled_coords + shared::math::coords{x, z};
+ const auto index_x = static_cast<unsigned long>(x + 1);
+ const auto index_z = static_cast<unsigned long>(z + 1);
+ point_arrays[index_x][index_z] = make_points(offset_coords);
+ }
+ }
+ return point_arrays;
+ }();
+
+ struct point_info {
+ struct point point;
+ glm::vec2 pos;
+ shared::math::coords coords;
+ float distance;
+ };
+ using point_info_vector = std::vector<point_info>;
+ const auto get_closest_point_infos =
+ [&](const glm::vec2 pos) -> point_info_vector {
+ std::vector<point_info> point_infos;
+ for (int x = -1; x <= 1; ++x) {
+ for (int z = -1; z <= 1; ++z) {
+ const glm::vec2 offset = {x, z};
+ const point_array& point_array =
+ point_arrays[static_cast<unsigned long>(x + 1)]
+ [static_cast<unsigned long>(z + 1)];
+
+ for (const auto& point : point_array) {
+
+ const float distance =
+ glm::distance(point.pos + offset, pos);
+ if (distance > 1.0f) {
+ continue;
+ }
+
+ point_infos.push_back(point_info{
+ .point = point,
+ .pos = point.pos,
+ .coords = shared::math::coords{x, z} + scaled_coords,
+ .distance = distance});
+ }
+ }
+ }
+ return point_infos;
+ };
+
+ const int x_offset = reflect_inner(coords.x, scale) * chunk::WIDTH;
+ const int z_offset = reflect_inner(coords.z, scale) * chunk::WIDTH;
+ const int scaled_width = chunk::WIDTH * scale;
+
+ // We generate a bit of perlin noise here so we can add some (jitter?)
+ // along our distances - the end result is less of an obvious line and more
+ // variance along our chunk borders.
+ constexpr int BIOME_JITTER_SCALE = 3;
+ const chunk_array jitter =
+ make_2d_perlin_array(seed, coords, BIOME_JITTER_SCALE);
+
+ // For our 2d array (ultimately columns of blocks in the world), we get the
+ // point that we're closest to in our world's voronoi noise points. For
+ // the points that are relevant (relatively close), we get the biome the
+ // point represents and add it to the column's array of biome influences.
+ // We ensure that these values add up to 1.0f. In the end, we have a struct
+ // that describes how much each biome affects each column as a %.
+ biome_array array = {};
+ for (auto x = 0u; x < chunk::WIDTH; ++x) {
+ const unsigned sx = x + static_cast<unsigned>(x_offset);
+
+ for (auto z = 0u; z < chunk::WIDTH; ++z) {
+ const unsigned sz = z + static_cast<unsigned>(z_offset);
+
+ const glm::vec2 inner_pos =
+ glm::vec2{static_cast<float>(sx) + 0.5f,
+ static_cast<float>(sz) + 0.5f} /
+ static_cast<float>(scaled_width) +
+ glm::vec2{std::sin(jitter[x][z]), std::cos(jitter[x][z])} *
+ 0.1f;
+
+ const auto point_infos = get_closest_point_infos(inner_pos);
+
+ float total_dominance = 0.0f;
+ for (const auto& point_info : point_infos) {
+ const auto index = get_biome_index(point_info.point.biome);
+ const float dominance = std::clamp(
+ -1.0f * std::pow(0.5f * point_info.distance - 1.0f, 21.0f),
+ 0.0f, 1.0f);
+
+ auto& loc = array[x][z][static_cast<unsigned long>(index)];
+ if (loc > dominance) {
+ continue;
+ }
+ const float diff = dominance - loc;
+ loc += diff;
+ total_dominance += diff;
+ }
+
+ for (float& dominance : array[x][z]) {
+ dominance *= (1.0f / total_dominance);
+ }
+ }
+ }
+ return array;
+}
+
+static auto array_map_access(const auto& array_map,
+ const shared::math::coords& coords, const int x,
+ const int z) noexcept {
+ const shared::math::coords normalised_coords =
+ chunk::get_normalised_chunk(coords, x, z);
+ const auto [nx, nz] = chunk::get_normalised_coords(x, z);
+ return array_map.find(normalised_coords)->second[nx][nz];
+}
+
+// We take a std::function that generates a chunk array to fill an unordered
+// map with a 3x3 chunk_array contents, where those contents refer to the
+// values in the surrounding chunks.
+static auto make_array_map(const std::uint64_t& seed,
+ const shared::math::coords& coords,
+ const auto& make_chunk_array_func) noexcept {
+
+ std::unordered_map<shared::math::coords,
+ decltype(make_chunk_array_func(seed, coords)),
+ decltype(&chunk::hash), decltype(&chunk::equal)>
+ array_map{9, chunk::hash, chunk::equal};
+ for (int x = -1; x <= 1; ++x) {
+ for (int z = -1; z <= 1; ++z) {
+ const shared::math::coords pos{coords + shared::math::coords{x, z}};
+ array_map.emplace(pos, make_chunk_array_func(seed, pos));
+ }
+ }
+
+ return array_map;
+}
+
+// These are constexpr for our static assert.
+static constexpr float
+get_biome_offset(const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ case chunk::biome::ocean:
+ case chunk::biome::islands:
+ return 0.0f;
+ default:
+ break;
+ }
+ return 10.0f;
+}
+
+static constexpr float
+get_biome_variation17(const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ case chunk::biome::alpine:
+ return 80.0f;
+ case chunk::biome::tundra:
+ return 10.0f;
+ case chunk::biome::forest:
+ return 30.0f;
+ case chunk::biome::ocean:
+ return 0.0f;
+ case chunk::biome::islands:
+ return 5.0f;
+ default:
+ break;
+ }
+ return 15.0f;
+}
+
+static constexpr float
+get_biome_variation11(const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ break;
+ case chunk::biome::alpine:
+ return 40.0f;
+ case chunk::biome::tundra:
+ return 30.0f;
+ default:
+ break;
+ }
+ return 20.0f;
+}
+
+static constexpr float
+get_biome_variation7(const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ case chunk::biome::alpine:
+ return 20.0f;
+ case chunk::biome::islands:
+ return 30.0f;
+ case chunk::biome::desert:
+ case chunk::biome::plains:
+ return 15.0f;
+ default:
+ break;
+ }
+ return 10.0f;
+}
+
+static constexpr float
+get_biome_variation3(const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ default:
+ break;
+ }
+ return 7.5f;
+}
+
+constexpr float BASE_HEIGHT = 40.0f;
+// Ensure any perlin values of our biome generation does not result in a y value
+// that is outside our max height.
+static_assert(std::ranges::all_of(biome_enums, [](const auto& biome) {
+ const float max_height =
+ BASE_HEIGHT + get_biome_offset(biome) + get_biome_variation3(biome) +
+ get_biome_variation7(biome) + get_biome_variation11(biome) +
+ get_biome_variation17(biome);
+ return max_height < static_cast<float>(chunk::HEIGHT);
+}));
+
+// Line that crosses at 0.5f, 0.5f with a variable gradient, should be clamped.
+static float linear_gradient(const float x, const float m) noexcept {
+ return m * (x - (0.5f - (0.5f / m)));
+}
+
+// The functions for ...these functions... should be domain and range [0, 1].
+static float process_variation(float variation,
+ const enum chunk::biome biome) noexcept {
+ switch (biome) {
+ case chunk::biome::alpine:
+ variation = linear_gradient(variation, 2.2f);
+ break;
+ default:
+ variation = linear_gradient(variation, 1.5f);
+ break;
+ }
+ return std::clamp(variation, 0.0f, 1.0f);
+}
+
+chunk_array make_topography(const std::uint64_t& seed,
+ const shared::math::coords& coords,
+ const biome_array_map& biome_map) noexcept {
+
+ chunk_array topography = {};
+
+ const biome_array& biomes = biome_map.find(coords)->second;
+ const chunk_array perlin17 = make_2d_perlin_array(seed, coords, 17);
+ const chunk_array perlin11 = make_2d_perlin_array(seed, coords, 11);
+ const chunk_array perlin7 = make_2d_perlin_array(seed, coords, 7);
+ const chunk_array perlin3 = make_2d_perlin_array(seed, coords, 3);
+
+ for (auto x = 0ul; x < chunk::WIDTH; ++x) {
+ for (auto z = 0ul; z < chunk::WIDTH; ++z) {
+
+ // Initial topography of 40.0f.
+ topography[x][z] = BASE_HEIGHT;
+
+ const auto biome_dominance = biomes[x][z];
+ for (auto i = 0u; i < std::size(biome_dominance); ++i) {
+ const enum chunk::biome biome = biome_enums[i];
+
+ const float dominance = biome_dominance[i];
+ const float v3 = process_variation(perlin3[x][z], biome) *
+ get_biome_variation3(biome);
+ const float v7 = process_variation(perlin7[x][z], biome) *
+ get_biome_variation7(biome);
+ const float v11 = process_variation(perlin11[x][z], biome) *
+ get_biome_variation11(biome);
+ const float v17 = process_variation(perlin17[x][z], biome) *
+ get_biome_variation17(biome);
+
+ topography[x][z] +=
+ (get_biome_offset(biome) + v3 + v7 + v11 + v17) * dominance;
+ }
+ }
+ }
+
+ return topography;
+}
+
+static chunk_array
+make_probabilities(const std::uint64_t& seed,
+ const shared::math::coords& coords) noexcept {
+
+ chunk_array chunk_array;
+
+ std::uniform_real_distribution<float> uniform{
+ 0.0f, std::nextafter(1.0f, std::numeric_limits<float>::max())};
+ std::ranlux48 generator(make_prandom(seed, coords));
+ for (auto x = 0ul; x < chunk::WIDTH; ++x) {
+ for (auto z = 0ul; z < chunk::WIDTH; ++z) {
+ chunk_array[x][z] = uniform(generator);
+ }
+ }
+
+ return chunk_array;
+}
+
+static biome_array make_biomes(const std::uint64_t& seed,
+ const shared::math::coords& coords) noexcept {
+
+ constexpr int BIOME_SCALE = 99;
+ return make_2d_biome_array(seed, coords, BIOME_SCALE);
+}
+
+constexpr int SAND_HEIGHT = 65;
+constexpr int WATER_HEIGHT = 63;
+
+constexpr int SAND_DEPTH = 5;
+constexpr int SANDSTONE_DEPTH = 6;
+constexpr int GRASS_DEPTH = 1;
+constexpr int DIRT_DEPTH = 7;
+
+// Rulesets common to all chunks go here. Water inhabits all blocks below 63
+// and above the topography value. In addition, stone fills all blocks after
+// the initial biome blocks.
+static void generate_post_terrain_column(chunk::block_array& blocks,
+ const glm::ivec3& pos,
+ const int lowest) noexcept {
+ for (int y = lowest; y > WATER_HEIGHT; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::sand;
+ }
+ for (int y = WATER_HEIGHT; y > pos.y; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::water;
+ }
+ for (int y = lowest; y >= 0; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::stone;
+ }
+}
+
+static int generate_sandy_terrain_column(chunk::block_array& blocks,
+ const glm::ivec3& pos) noexcept {
+ int y = pos.y;
+ for (const int lowest = y - SAND_DEPTH; y > lowest; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::sand;
+ }
+ for (const int lowest = y - SANDSTONE_DEPTH; y > lowest; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::sandstone;
+ }
+ return y;
+}
+
+static int generate_grassy_terrain_column(chunk::block_array& blocks,
+ const glm::ivec3& pos,
+ const enum block::type top) noexcept {
+ int y = pos.y;
+ if (y <= SAND_HEIGHT) {
+ for (const int lowest = y - SAND_DEPTH; y > lowest; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::sand;
+ }
+ } else {
+ for (const int lowest = y - GRASS_DEPTH; y > lowest; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = top;
+ }
+ for (const int lowest = y - DIRT_DEPTH; y > lowest; --y) {
+ blocks[chunk::get_3d_index({pos.x, y, pos.z})] = block::type::dirt;
+ }
+ }
+ return y;
+}
+
+static void generate_terrain_column(chunk::block_array& blocks,
+ const glm::ivec3& pos,
+ const enum chunk::biome biome) noexcept {
+ const int lowest = [&]() {
+ switch (biome) {
+ case chunk::biome::desert:
+ return generate_sandy_terrain_column(blocks, pos);
+
+ case chunk::biome::islands:
+ case chunk::biome::forest:
+ case chunk::biome::plains:
+ case chunk::biome::ocean:
+ return generate_grassy_terrain_column(blocks, pos,
+ block::type::grass);
+
+ case chunk::biome::tundra:
+ case chunk::biome::alpine:
+ return generate_grassy_terrain_column(blocks, pos,
+ block::type::snow);
+ }
+ }();
+
+ generate_post_terrain_column(blocks, pos, lowest);
+}
+
+static enum chunk::biome get_dominant_biome(const auto& array) noexcept {
+ const auto max_it =
+ std::max_element(std::begin(array), std::end(array),
+ [](const auto& a, const auto& b) { return a < b; });
+ return biome_enums[static_cast<unsigned long>(
+ std::distance(std::begin(array), max_it))];
+}
+
+static void generate_terrain(chunk::block_array& blocks,
+ const shared::math::coords& coords,
+ const chunk_array_map& topography_map,
+ const biome_array_map& biome_map) noexcept {
+
+ const biome_array& biomes = biome_map.find(coords)->second;
+ const chunk_array& topography = topography_map.find(coords)->second;
+
+ // We fill in our chunk column by column, where the column refers to a
+ // function which maps to a biome.
+ for (unsigned long x = 0ul; x < chunk::WIDTH; ++x) {
+ for (unsigned long z = 0ul; z < chunk::WIDTH; ++z) {
+ generate_terrain_column(blocks, glm::vec3{x, topography[x][z], z},
+ get_dominant_biome(biomes[x][z]));
+ }
+ }
+}
+
+// Objects have a max WIDTH, but no max WIDTH.
+constexpr int MAX_OBJECT_WIDTH = 5;
+constexpr int OBJECT_HALFWIDTH = MAX_OBJECT_WIDTH / 2;
+// A layer is an x, z slice of an object.
+using object_layer =
+ std::array<std::array<block, MAX_OBJECT_WIDTH>, MAX_OBJECT_WIDTH>;
+using object = std::vector<object_layer>;
+struct biome_object {
+ const object* const blocks;
+ const float probability;
+ const int altitude; // lowest alt we can gen at
+};
+using biome_objects = std::vector<biome_object>;
+
+static object make_tree_object() noexcept {
+ object tree;
+ object_layer layer = {};
+
+ layer[OBJECT_HALFWIDTH][OBJECT_HALFWIDTH] = block::type::wood;
+ for (int i = 0; i < 3; ++i) {
+ tree.push_back(layer);
+ }
+
+ for (unsigned x = 0; x < std::size(layer); ++x) {
+ for (unsigned z = 0; z < std::size(layer); ++z) {
+ if (x == OBJECT_HALFWIDTH && z == OBJECT_HALFWIDTH) {
+ continue;
+ }
+ layer[x][z] = block::type::leaves;
+ }
+ }
+ for (int i = 0; i < 2; ++i) {
+ tree.push_back(layer);
+ }
+ for (unsigned x = 0; x < std::size(layer); ++x) {
+ for (unsigned z = 0; z < std::size(layer); ++z) {
+ if (!(x == 0 || x == 4 || z == 0 || z == 4)) {
+ continue;
+ }
+ layer[x][z] = block::type::air;
+ }
+ }
+ tree.push_back(layer);
+ for (unsigned x = 0; x < std::size(layer); ++x) {
+ for (unsigned z = 0; z < std::size(layer); ++z) {
+ if (x < 1 || x > 3 || z < 1 || z > 3 ||
+ (std::abs(int(x) - 2) + std::abs(int(z) - 2) == 2)) {
+ layer[x][z] = block::type::air;
+ continue;
+ }
+ layer[x][z] = block::type::leaves;
+ }
+ }
+ tree.push_back(layer);
+ return tree;
+}
+
+static object make_alpine_tree() noexcept {
+ object tree;
+ object_layer layer = {};
+
+ layer[OBJECT_HALFWIDTH][OBJECT_HALFWIDTH] = block::type::snowy_wood;
+ constexpr int HEIGHT = 10;
+ for (int y = 0; y <= HEIGHT; ++y) {
+
+ constexpr float BASE_RAD = static_cast<float>(MAX_OBJECT_WIDTH) / 2.0f;
+
+ const float radius =
+ BASE_RAD * std::exp(-1.0f * (static_cast<float>(y) /
+ static_cast<float>(HEIGHT)));
+
+ for (unsigned x = 0; x < MAX_OBJECT_WIDTH; ++x) {
+ for (unsigned z = 0; z < MAX_OBJECT_WIDTH; ++z) {
+ if (x == OBJECT_HALFWIDTH && z == OBJECT_HALFWIDTH) {
+ if (y == HEIGHT) {
+ layer[x][z] = block::type::snowy_leaves;
+ }
+
+ continue; // leave as wood
+ }
+
+ if ((y + 1) % 2) {
+ layer[x][z] = block::type::air;
+ continue;
+ }
+
+ const float lhs = std::pow((float)x - 2.0f, 2.0f) +
+ std::pow((float)z - 2.0f, 2.0f);
+ const float rhs = std::pow(radius, 2.0f);
+
+ layer[x][z] =
+ lhs < rhs ? block::type::snowy_leaves : block::type::air;
+ }
+ }
+
+ tree.push_back(layer);
+ }
+
+ return tree;
+}
+
+static object make_column_object(const enum block::type type,
+ const int WIDTH) noexcept {
+ object obj;
+ object_layer layer = {};
+
+ layer[OBJECT_HALFWIDTH][OBJECT_HALFWIDTH] = type;
+ for (int i = 0; i < WIDTH; ++i) {
+ obj.push_back(layer);
+ }
+ return obj;
+}
+
+static const biome_objects&
+get_biome_objects(const chunk::biome biome) noexcept {
+ using btype = enum block::type;
+ static const object tree = make_tree_object();
+ static const object alpine_tree = make_alpine_tree();
+ static const object cactus1 = make_column_object(btype::cactus, 1);
+ static const object cactus2 = make_column_object(btype::cactus, 2);
+ static const object cactus3 = make_column_object(btype::cactus, 3);
+ static const object grass = make_column_object(btype::shrub, 1);
+ static const object dead_shrub = make_column_object(btype::dead_shrub, 1);
+ static const object snowy_grass = make_column_object(btype::snowy_shrub, 1);
+
+ switch (biome) {
+ case chunk::biome::islands:
+ static const biome_objects island_objects{
+ biome_object{&tree, 0.0005f, SAND_HEIGHT},
+ biome_object{&grass, 0.025f, SAND_HEIGHT}};
+ return island_objects;
+
+ case chunk::biome::plains:
+ static const biome_objects plains_objects{
+ biome_object{&tree, 0.0005f, SAND_HEIGHT},
+ biome_object{&grass, 0.1f, SAND_HEIGHT}};
+ return plains_objects;
+
+ case chunk::biome::forest:
+ static const biome_objects forest_objects{
+ biome_object{&tree, 0.01f, SAND_HEIGHT},
+ biome_object{&grass, 0.1f, SAND_HEIGHT}};
+ return forest_objects;
+
+ case chunk::biome::desert:
+ static const biome_objects desert_objects{
+ biome_object{&cactus1, 0.0002f, WATER_HEIGHT},
+ biome_object{&cactus2, 0.0005f, WATER_HEIGHT},
+ biome_object{&cactus3, 0.0009f, WATER_HEIGHT},
+ biome_object{&dead_shrub, 0.0012f, WATER_HEIGHT}};
+ return desert_objects;
+
+ case chunk::biome::alpine:
+ static const biome_objects alpine_objects{
+ biome_object{&alpine_tree, 0.0008f, SAND_HEIGHT},
+ biome_object{&snowy_grass, 0.0025f, SAND_HEIGHT}};
+ return alpine_objects;
+
+ case chunk::biome::tundra:
+ static const biome_objects tundra_objects{
+ biome_object{&alpine_tree, 0.0008f, SAND_HEIGHT},
+ biome_object{&snowy_grass, 0.004f, SAND_HEIGHT}};
+ return tundra_objects;
+
+ case chunk::biome::ocean:
+ static const biome_objects ocean_objects{
+ biome_object{&tree, 0.001f, SAND_HEIGHT},
+ biome_object{&grass, 0.1f, SAND_HEIGHT}};
+ return ocean_objects;
+ }
+}
+
+static std::optional<biome_object>
+maybe_get_object(const float probability, const chunk::biome biome) noexcept {
+ const auto& biome_objects = get_biome_objects(biome);
+
+ const auto find_it =
+ std::ranges::find_if(biome_objects, [&](const auto& object) {
+ return object.probability >= probability;
+ });
+
+ if (find_it != std::end(biome_objects)) {
+ return *find_it;
+ }
+ return std::nullopt;
+}
+
+static int get_block_priority(const enum block::type& b) noexcept {
+ switch (b) {
+ case block::type::air:
+ return 0;
+ case block::type::leaves:
+ case block::type::snowy_leaves:
+ return 1;
+ default:
+ break;
+ }
+ return 2;
+}
+
+static void generate_object(const object& object, chunk::block_array& blocks,
+ const glm::ivec3& pos) noexcept {
+ for (unsigned y = 0; y < std::size(object); ++y) {
+
+ const auto& layer = object[y];
+ for (unsigned x = 0; x < std::size(layer); ++x) {
+ for (unsigned z = 0; z < std::size(layer); ++z) {
+
+ const block block = layer[x][z];
+ if (block == block::type::air) {
+ continue;
+ }
+
+ const glm::ivec3 block_pos =
+ pos + glm::ivec3{x - MAX_OBJECT_WIDTH / 2, y + 1,
+ z - MAX_OBJECT_WIDTH / 2};
+ if (chunk::is_outside_chunk(block_pos)) {
+ continue;
+ }
+
+ const auto index = chunk::get_3d_index(block_pos);
+
+ const class block old_block = blocks[index];
+ if (get_block_priority(block) < get_block_priority(old_block)) {
+ continue;
+ }
+
+ blocks[index] = block;
+ }
+ }
+ }
+}
+
+static void generate_objects(chunk::block_array& blocks,
+ const shared::math::coords& coords,
+ const chunk_array_map& topography_map,
+ const biome_array_map& biome_map,
+ const chunk_array_map& probability_map) noexcept {
+
+ // This is really expensive as it is x^2
+ // We don't want to create any structures that are very wide as a result.
+ // (at least, structures which generate via this method).
+ const int MAX_READ = MAX_OBJECT_WIDTH / 2;
+ for (int x = -MAX_READ; x < MAX_READ + chunk::WIDTH; ++x) {
+ for (int z = -MAX_READ; z < MAX_READ + chunk::WIDTH; ++z) {
+ const float probability =
+ array_map_access(probability_map, coords, x, z);
+ const chunk::biome biome =
+ get_dominant_biome(array_map_access(biome_map, coords, x, z));
+
+ const auto& object = maybe_get_object(probability, biome);
+ if (!object.has_value()) {
+ continue;
+ }
+
+ const glm::ivec3 pos{
+ x, array_map_access(topography_map, coords, x, z), z};
+
+ if (pos.y <= object->altitude) {
+ continue;
+ }
+
+ generate_object(*object->blocks, blocks, pos);
+ }
+ }
+}
+
+static chunk::block_array
+generate_blocks(const std::uint64_t& seed,
+ const shared::math::coords& coords) noexcept {
+
+ const biome_array_map biome_arrays =
+ make_array_map(seed, coords, make_biomes);
+ // Topography relies on block temperature so we bind it as a hidden
+ // third argument as to avoid unnecessary generation.
+ const chunk_array_map topography_arrays =
+ make_array_map(seed, coords,
+ std::bind(make_topography, std::placeholders::_1,
+ std::placeholders::_2, biome_arrays));
+
+ const chunk_array_map probability_map =
+ make_array_map(seed, coords, make_probabilities);
+
+ chunk::block_array blocks = {};
+
+ // Must be called in order, generate_objects relies on generate terrain etc.
+ generate_terrain(blocks, coords, topography_arrays, biome_arrays);
+ generate_objects(blocks, coords, topography_arrays, biome_arrays,
+ probability_map);
+ // generate caves
+ // generate better terrain generation
+ return blocks;
+}
+
+// Use perlin noise and extrapolation of eigen vectors along a mobius strip.
+chunk::chunk(const std::uint64_t& seed, const shared::math::coords& coords,
+ std::optional<decltype(chunk::blocks)> blocks) noexcept
+ : pos(coords) {
+ if (blocks.has_value()) {
+ this->blocks = std::move(blocks.value());
+ return;
+ }
+
+ this->blocks = generate_blocks(seed, coords);
+}
+
+} // namespace world
+} // namespace shared
diff --git a/src/shared/world.hh b/src/shared/world.hh
new file mode 100644
index 0000000..3969992
--- /dev/null
+++ b/src/shared/world.hh
@@ -0,0 +1,224 @@
+#ifndef SHARED_WORLD_HH_
+#define SHARED_WORLD_HH_
+
+#include <algorithm>
+#include <array>
+#include <exception>
+#include <functional>
+#include <istream>
+#include <memory>
+#include <random>
+#include <type_traits>
+#include <vector>
+
+#include <boost/functional/hash.hpp>
+#include <glm/glm.hpp>
+
+#include "shared/math.hh"
+#include "shared/net/proto.hh"
+#include "shared/shared.hh"
+
+namespace shared {
+namespace world {
+
+class block {
+public:
+ enum class type : std::uint8_t {
+ air, // zero means air which means don't render
+ dirt, // atlas should start from here
+ grass,
+ sand,
+ sandstone,
+ stone,
+ cobblestone,
+ wood,
+ leaves,
+ water,
+ shrub,
+ snow,
+ cactus,
+ dead_shrub,
+ snowy_wood,
+ snowy_leaves,
+ snowy_shrub,
+ };
+ enum class visibility { solid, partial, translucent, invisible };
+
+public:
+ type type;
+
+public:
+ static constexpr enum block::visibility
+ get_visibility(const enum block::type type) noexcept {
+ switch (type) {
+ case type::air:
+ return visibility::invisible;
+ case type::shrub:
+ case type::dead_shrub:
+ case type::leaves:
+ case type::snowy_leaves:
+ case type::snowy_shrub:
+ return visibility::partial;
+ case type::water:
+ return visibility::translucent;
+ default:
+ break;
+ }
+ return visibility::solid;
+ }
+ static constexpr bool is_tangible(const enum block::type type) noexcept {
+ switch (type) {
+ case type::air:
+ case type::shrub:
+ case type::dead_shrub:
+ case type::snowy_shrub:
+ return false;
+ default:
+ break;
+ }
+ return true;
+ }
+ static constexpr bool is_collidable(const enum block::type type) noexcept {
+ switch (type) {
+ case type::air:
+ case type::shrub:
+ case type::dead_shrub:
+ case type::snowy_shrub:
+ case type::water:
+ return false;
+ default:
+ break;
+ }
+ return true;
+ }
+ static constexpr bool is_liquid(const enum block::type type) noexcept {
+ switch (type) {
+ case type::water:
+ return true;
+ default:
+ break;
+ }
+ return false;
+ }
+ static constexpr bool is_replaceable(const enum block::type type) noexcept {
+ switch (type) {
+ case type::water:
+ case type::air:
+ return true;
+ default:
+ break;
+ }
+ return false;
+ }
+ static constexpr bool is_removable(const enum block::type type) noexcept {
+ switch (type) {
+ case type::water:
+ case type::air:
+ return false;
+ default:
+ break;
+ }
+ return true;
+ }
+ static constexpr float get_friction(const enum block::type type) noexcept {
+ switch (type) {
+ case type::water:
+ return 20.0f;
+ case type::air:
+ case type::shrub:
+ case type::dead_shrub:
+ case type::snowy_shrub:
+ return 0.1f;
+ default:
+ break;
+ }
+ return 10.0f;
+ }
+
+public:
+ block(const enum block::type t = type::air) noexcept : type(t) {}
+
+ operator enum block::type() const noexcept { return this->type; }
+};
+
+class chunk {
+public:
+ static constexpr int WIDTH = 16;
+ static constexpr int HEIGHT = 256;
+ static constexpr int VOLUME = WIDTH * WIDTH * HEIGHT;
+
+ // Stuff for unordered_map.
+ static std::size_t hash(const shared::math::coords& c) noexcept {
+ std::size_t seed = 0;
+ boost::hash_combine(seed, boost::hash_value(c.x));
+ boost::hash_combine(seed, boost::hash_value(c.z));
+ return seed;
+ }
+ static std::size_t equal(const shared::math::coords& a,
+ const shared::math::coords& b) noexcept {
+ return a == b;
+ }
+ using map = std::unordered_map<shared::math::coords, shared::world::chunk,
+ decltype(&shared::world::chunk::hash),
+ decltype(&shared::world::chunk::equal)>;
+
+protected:
+ shared::math::coords pos;
+ std::array<block, VOLUME> blocks; // Use get_block for 3d index access.
+
+public:
+ using block_array = decltype(chunk::blocks);
+ enum class biome { desert, islands, ocean, plains, forest, tundra, alpine };
+
+ static bool is_outside_chunk(const glm::ivec3& v) noexcept {
+ return (std::min(v.x, v.z) < 0) || (std::max(v.x, v.z) >= WIDTH) ||
+ (std::clamp(v.y, 0, HEIGHT - 1) != v.y);
+ }
+ static shared::math::coords
+ get_normalised_chunk(const shared::math::coords& coords, const int x,
+ const int z) noexcept {
+ return coords + shared::math::coords{(x >= WIDTH) - (x < 0),
+ (z >= WIDTH) - (z < 0)};
+ }
+ static std::pair<unsigned short, unsigned short>
+ get_normalised_coords(const int x, const int z) noexcept {
+ return {x + WIDTH * ((x < 0) - (x >= WIDTH)),
+ z + WIDTH * ((z < 0) - (z >= WIDTH))};
+ }
+ static glm::ivec3 get_normalised_coords(const glm::ivec3& c) noexcept {
+ const auto [x, z] = get_normalised_coords(c.x, c.z);
+ return {x, c.y, z};
+ }
+ static block_array
+ make_blocks_from_chunk(const proto::chunk& chunk) noexcept;
+
+public:
+ static unsigned long get_3d_index(const glm::ivec3& v) noexcept {
+#ifndef NDEBUG
+ if (is_outside_chunk(v)) {
+ throw std::range_error("bad chunk block coordinate access");
+ }
+#endif
+ return static_cast<unsigned long>(v.x +
+ (WIDTH * (v.y + (HEIGHT * v.z))));
+ }
+
+public:
+ // If a third non-std::nullopt argument is provided, we use those blocks
+ // instead of what we might have otherwise generated.
+ chunk(const std::uint64_t& seed, const shared::math::coords& coords,
+ const std::optional<block_array> blocks = std::nullopt) noexcept;
+
+ shared::math::coords get_pos() const noexcept { return this->pos; }
+ block get_block(const glm::ivec3& v) const noexcept {
+ return this->blocks[get_3d_index(v)];
+ }
+ block& get_block(const glm::ivec3& v) noexcept {
+ return this->blocks[get_3d_index(v)];
+ }
+};
+
+} // namespace world
+} // namespace shared
+
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2026-01-13 16:06:41 +0000