initial commit

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