From 6c2abde5c99a236453b795abaa6d7d70105e31f7 Mon Sep 17 00:00:00 2001
From: untodesu <kirill@untode.su>
Date: Fri, 26 Dec 2025 14:50:33 +0500
Subject: Just a big Ctrl+H refactoring

---
 src/game/client/entity/camera.cc        | 69 ++++++++++++++++-----------------
 src/game/client/entity/camera.hh        | 12 +++---
 src/game/client/entity/factory.cc       | 18 ++++-----
 src/game/client/entity/factory.hh       |  9 ++---
 src/game/client/entity/interpolation.cc |  7 ++--
 src/game/client/entity/interpolation.hh |  4 +-
 src/game/client/entity/listener.cc      | 12 +++---
 src/game/client/entity/listener.hh      |  4 +-
 src/game/client/entity/player_look.cc   | 24 ++++++------
 src/game/client/entity/player_look.hh   |  4 +-
 src/game/client/entity/player_move.cc   | 36 ++++++++---------
 src/game/client/entity/player_move.hh   |  4 +-
 src/game/client/entity/sound_emitter.cc | 14 +++----
 src/game/client/entity/sound_emitter.hh |  3 --
 14 files changed, 106 insertions(+), 114 deletions(-)

(limited to 'src/game/client/entity')

diff --git a/src/game/client/entity/camera.cc b/src/game/client/entity/camera.cc
index 3badd9d..2009066 100644
--- a/src/game/client/entity/camera.cc
+++ b/src/game/client/entity/camera.cc
@@ -23,23 +23,23 @@
 #include "client/session.hh"
 #include "client/toggles.hh"
 
-config::Float entity::camera::roll_angle(2.0f, 0.0f, 4.0f);
-config::Float entity::camera::vertical_fov(90.0f, 45.0f, 110.0f);
-config::Unsigned entity::camera::view_distance(16U, 4U, 32U);
+config::Float camera::roll_angle(2.0f, 0.0f, 4.0f);
+config::Float camera::vertical_fov(90.0f, 45.0f, 110.0f);
+config::Unsigned camera::view_distance(16U, 4U, 32U);
 
-glm::fvec3 entity::camera::angles;
-glm::fvec3 entity::camera::direction;
-glm::fmat4x4 entity::camera::matrix;
-chunk_pos entity::camera::position_chunk;
-glm::fvec3 entity::camera::position_local;
+glm::fvec3 camera::angles;
+glm::fvec3 camera::direction;
+glm::fmat4x4 camera::matrix;
+chunk_pos camera::position_chunk;
+glm::fvec3 camera::position_local;
 
 static void reset_camera(void)
 {
-    entity::camera::angles = glm::fvec3(0.0f, 0.0f, 0.0f);
-    entity::camera::direction = DIR_FORWARD<float>;
-    entity::camera::matrix = glm::identity<glm::fmat4x4>();
-    entity::camera::position_chunk = chunk_pos(0, 0, 0);
-    entity::camera::position_local = glm::fvec3(0.0f, 0.0f, 0.0f);
+    camera::angles = glm::fvec3(0.0f, 0.0f, 0.0f);
+    camera::direction = DIR_FORWARD<float>;
+    camera::matrix = glm::identity<glm::fmat4x4>();
+    camera::position_chunk = chunk_pos(0, 0, 0);
+    camera::position_local = glm::fvec3(0.0f, 0.0f, 0.0f);
 }
 
 // Gracefully contributed by PQCraft himself in 2024
@@ -65,50 +65,49 @@ static glm::fmat4x4 platinumsrc_viewmatrix(const glm::fvec3& position, const glm
     return result;
 }
 
-void entity::camera::init(void)
+void camera::init(void)
 {
-    globals::client_config.add_value("camera.roll_angle", entity::camera::roll_angle);
-    globals::client_config.add_value("camera.vertical_fov", entity::camera::vertical_fov);
-    globals::client_config.add_value("camera.view_distance", entity::camera::view_distance);
+    globals::client_config.add_value("camera.roll_angle", camera::roll_angle);
+    globals::client_config.add_value("camera.vertical_fov", camera::vertical_fov);
+    globals::client_config.add_value("camera.view_distance", camera::view_distance);
 
-    settings::add_slider(1, entity::camera::vertical_fov, settings_location::GENERAL, "camera.vertical_fov", true, "%.0f");
-    settings::add_slider(0, entity::camera::view_distance, settings_location::VIDEO, "camera.view_distance", false);
-    settings::add_slider(10, entity::camera::roll_angle, settings_location::VIDEO, "camera.roll_angle", true, "%.01f");
+    settings::add_slider(1, camera::vertical_fov, settings_location::GENERAL, "camera.vertical_fov", true, "%.0f");
+    settings::add_slider(0, camera::view_distance, settings_location::VIDEO, "camera.view_distance", false);
+    settings::add_slider(10, camera::roll_angle, settings_location::VIDEO, "camera.roll_angle", true, "%.01f");
 
     reset_camera();
 }
 
-void entity::camera::update(void)
+void camera::update(void)
 {
     if(!session::is_ingame()) {
         reset_camera();
         return;
     }
 
-    const auto& head = globals::dimension->entities.get<entity::client::HeadIntr>(globals::player);
-    const auto& transform = globals::dimension->entities.get<entity::client::TransformIntr>(globals::player);
-    const auto& velocity = globals::dimension->entities.get<entity::Velocity>(globals::player);
+    const auto& head = globals::dimension->entities.get<client::HeadIntr>(globals::player);
+    const auto& transform = globals::dimension->entities.get<client::TransformIntr>(globals::player);
+    const auto& velocity = globals::dimension->entities.get<Velocity>(globals::player);
 
-    entity::camera::angles = transform.angles + head.angles;
-    entity::camera::position_chunk = transform.chunk;
-    entity::camera::position_local = transform.local + head.offset;
+    camera::angles = transform.angles + head.angles;
+    camera::position_chunk = transform.chunk;
+    camera::position_local = transform.local + head.offset;
 
     glm::fvec3 right_vector, up_vector;
-    math::vectors(entity::camera::angles, &entity::camera::direction, &right_vector, &up_vector);
+    math::vectors(camera::angles, &camera::direction, &right_vector, &up_vector);
 
-    auto client_angles = entity::camera::angles;
+    auto client_angles = camera::angles;
 
     if(!toggles::get(TOGGLE_PM_FLIGHT)) {
         // Apply the quake-like view rolling
-        client_angles[2] = math::radians(-entity::camera::roll_angle.get_value()
-            * glm::dot(velocity.value / PMOVE_MAX_SPEED_GROUND, right_vector));
+        client_angles[2] = math::radians(-camera::roll_angle.get_value() * glm::dot(velocity.value / PMOVE_MAX_SPEED_GROUND, right_vector));
     }
 
     const auto z_near = 0.01f;
-    const auto z_far = 1.25f * static_cast<float>(CHUNK_SIZE * entity::camera::view_distance.get_value());
+    const auto z_far = 1.25f * static_cast<float>(CHUNK_SIZE * camera::view_distance.get_value());
 
-    auto proj = glm::perspective(math::radians(entity::camera::vertical_fov.get_value()), globals::aspect, z_near, z_far);
-    auto view = platinumsrc_viewmatrix(entity::camera::position_local, client_angles);
+    auto proj = glm::perspective(math::radians(camera::vertical_fov.get_value()), globals::aspect, z_near, z_far);
+    auto view = platinumsrc_viewmatrix(camera::position_local, client_angles);
 
-    entity::camera::matrix = proj * view;
+    camera::matrix = proj * view;
 }
diff --git a/src/game/client/entity/camera.hh b/src/game/client/entity/camera.hh
index 67baf72..526bc91 100644
--- a/src/game/client/entity/camera.hh
+++ b/src/game/client/entity/camera.hh
@@ -8,24 +8,24 @@ class Float;
 class Unsigned;
 } // namespace config
 
-namespace entity::camera
+namespace camera
 {
 extern config::Float roll_angle;
 extern config::Float vertical_fov;
 extern config::Unsigned view_distance;
-} // namespace entity::camera
+} // namespace camera
 
-namespace entity::camera
+namespace camera
 {
 extern glm::fvec3 angles;
 extern glm::fvec3 direction;
 extern glm::fmat4x4 matrix;
 extern chunk_pos position_chunk;
 extern glm::fvec3 position_local;
-} // namespace entity::camera
+} // namespace camera
 
-namespace entity::camera
+namespace camera
 {
 void init(void);
 void update(void);
-} // namespace entity::camera
+} // namespace camera
diff --git a/src/game/client/entity/factory.cc b/src/game/client/entity/factory.cc
index f6f6079..f4724c5 100644
--- a/src/game/client/entity/factory.cc
+++ b/src/game/client/entity/factory.cc
@@ -12,19 +12,19 @@
 
 #include "client/globals.hh"
 
-void entity::client::create_player(world::Dimension* dimension, entt::entity entity)
+void client::create_player(Dimension* dimension, entt::entity entity)
 {
-    entity::shared::create_player(dimension, entity);
+    shared::create_player(dimension, entity);
 
-    const auto& head = dimension->entities.get<entity::Head>(entity);
-    dimension->entities.emplace_or_replace<entity::client::HeadIntr>(entity, head);
-    dimension->entities.emplace_or_replace<entity::client::HeadPrev>(entity, head);
+    const auto& head = dimension->entities.get<Head>(entity);
+    dimension->entities.emplace_or_replace<client::HeadIntr>(entity, head);
+    dimension->entities.emplace_or_replace<client::HeadPrev>(entity, head);
 
-    const auto& transform = dimension->entities.get<entity::Transform>(entity);
-    dimension->entities.emplace_or_replace<entity::client::TransformIntr>(entity, transform);
-    dimension->entities.emplace_or_replace<entity::client::TransformPrev>(entity, transform);
+    const auto& transform = dimension->entities.get<Transform>(entity);
+    dimension->entities.emplace_or_replace<client::TransformIntr>(entity, transform);
+    dimension->entities.emplace_or_replace<client::TransformPrev>(entity, transform);
 
     if(globals::sound_ctx) {
-        dimension->entities.emplace_or_replace<entity::SoundEmitter>(entity);
+        dimension->entities.emplace_or_replace<SoundEmitter>(entity);
     }
 }
diff --git a/src/game/client/entity/factory.hh b/src/game/client/entity/factory.hh
index 63e6e44..776a0b8 100644
--- a/src/game/client/entity/factory.hh
+++ b/src/game/client/entity/factory.hh
@@ -1,11 +1,8 @@
 #pragma once
 
-namespace world
-{
 class Dimension;
-} // namespace world
 
-namespace entity::client
+namespace client
 {
-void create_player(world::Dimension* dimension, entt::entity entity);
-} // namespace entity::client
+void create_player(Dimension* dimension, entt::entity entity);
+} // namespace client
diff --git a/src/game/client/entity/interpolation.cc b/src/game/client/entity/interpolation.cc
index a9a3349..69fd487 100644
--- a/src/game/client/entity/interpolation.cc
+++ b/src/game/client/entity/interpolation.cc
@@ -15,8 +15,7 @@
 
 static void transform_interpolate(float alpha)
 {
-    auto group = globals::dimension->entities.group<entity::client::TransformIntr>(
-        entt::get<entity::Transform, entity::client::TransformPrev>);
+    auto group = globals::dimension->entities.group<client::TransformIntr>(entt::get<Transform, client::TransformPrev>);
 
     for(auto [entity, interp, current, previous] : group.each()) {
         interp.angles[0] = glm::mix(previous.angles[0], current.angles[0], alpha);
@@ -41,7 +40,7 @@ static void transform_interpolate(float alpha)
 
 static void head_interpolate(float alpha)
 {
-    auto group = globals::dimension->entities.group<entity::client::HeadIntr>(entt::get<entity::Head, entity::client::HeadPrev>);
+    auto group = globals::dimension->entities.group<client::HeadIntr>(entt::get<Head, client::HeadPrev>);
 
     for(auto [entity, interp, current, previous] : group.each()) {
         interp.angles[0] = glm::mix(previous.angles[0], current.angles[0], alpha);
@@ -54,7 +53,7 @@ static void head_interpolate(float alpha)
     }
 }
 
-void entity::interpolation::update(void)
+void interpolation::update(void)
 {
     if(globals::dimension) {
         auto alpha = static_cast<float>(globals::fixed_accumulator) / static_cast<float>(globals::fixed_frametime_us);
diff --git a/src/game/client/entity/interpolation.hh b/src/game/client/entity/interpolation.hh
index 6935fe8..8fb0db1 100644
--- a/src/game/client/entity/interpolation.hh
+++ b/src/game/client/entity/interpolation.hh
@@ -1,6 +1,6 @@
 #pragma once
 
-namespace entity::interpolation
+namespace interpolation
 {
 void update(void);
-} // namespace entity::interpolation
+} // namespace interpolation
diff --git a/src/game/client/entity/listener.cc b/src/game/client/entity/listener.cc
index a79e8a5..991f014 100644
--- a/src/game/client/entity/listener.cc
+++ b/src/game/client/entity/listener.cc
@@ -18,19 +18,19 @@
 #include "client/globals.hh"
 #include "client/session.hh"
 
-void entity::listener::update(void)
+void listener::update(void)
 {
     if(session::is_ingame()) {
-        const auto& velocity = globals::dimension->entities.get<entity::Velocity>(globals::player).value;
-        const auto& position = entity::camera::position_local;
+        const auto& velocity = globals::dimension->entities.get<Velocity>(globals::player).value;
+        const auto& position = camera::position_local;
 
         alListener3f(AL_POSITION, position.x, position.y, position.z);
         alListener3f(AL_VELOCITY, velocity.x, velocity.y, velocity.z);
 
         float orientation[6];
-        orientation[0] = entity::camera::direction.x;
-        orientation[1] = entity::camera::direction.y;
-        orientation[2] = entity::camera::direction.z;
+        orientation[0] = camera::direction.x;
+        orientation[1] = camera::direction.y;
+        orientation[2] = camera::direction.z;
         orientation[3] = DIR_UP<float>.x;
         orientation[4] = DIR_UP<float>.y;
         orientation[5] = DIR_UP<float>.z;
diff --git a/src/game/client/entity/listener.hh b/src/game/client/entity/listener.hh
index 594cde1..07d750f 100644
--- a/src/game/client/entity/listener.hh
+++ b/src/game/client/entity/listener.hh
@@ -1,6 +1,6 @@
 #pragma once
 
-namespace entity::listener
+namespace listener
 {
 void update(void);
-} // namespace entity::listener
+} // namespace listener
diff --git a/src/game/client/entity/player_look.cc b/src/game/client/entity/player_look.cc
index 0752e78..ad0f40e 100644
--- a/src/game/client/entity/player_look.cc
+++ b/src/game/client/entity/player_look.cc
@@ -51,7 +51,7 @@ static glm::fvec2 last_cursor;
 static void add_angles(float pitch, float yaw)
 {
     if(session::is_ingame()) {
-        auto& head = globals::dimension->entities.get<entity::Head>(globals::player);
+        auto& head = globals::dimension->entities.get<Head>(globals::player);
 
         head.angles[0] += pitch;
         head.angles[1] += yaw;
@@ -62,13 +62,13 @@ static void add_angles(float pitch, float yaw)
         // Re-assigning the previous state after the current
         // state has been already modified is certainly a way
         // to circumvent the interpolation applied to anything with a head
-        globals::dimension->entities.emplace_or_replace<entity::client::HeadPrev>(globals::player, head);
+        globals::dimension->entities.emplace_or_replace<client::HeadPrev>(globals::player, head);
     }
 }
 
-static void on_glfw_cursor_pos(const io::GlfwCursorPosEvent& event)
+static void on_glfw_cursor_pos(const GlfwCursorPosEvent& event)
 {
-    if(io::gamepad::available && io::gamepad::active.get_value()) {
+    if(gamepad::available && gamepad::active.get_value()) {
         // The player is assumed to be using
         // a gamepad instead of mouse and keyboard
         last_cursor = event.pos;
@@ -88,14 +88,14 @@ static void on_glfw_cursor_pos(const io::GlfwCursorPosEvent& event)
     last_cursor = event.pos;
 }
 
-static void on_gamepad_button(const io::GamepadButtonEvent& event)
+static void on_gamepad_button(const GamepadButtonEvent& event)
 {
     if(button_fastlook.equals(event.button)) {
         fastlook_enabled = event.action == GLFW_PRESS;
     }
 }
 
-void entity::player_look::init(void)
+void player_look::init(void)
 {
     globals::client_config.add_value("player_look.mouse.raw_input", mouse_raw_input);
     globals::client_config.add_value("player_look.mouse.sensitivity", mouse_sensitivity);
@@ -121,15 +121,15 @@ void entity::player_look::init(void)
     last_cursor.x = 0.5f * static_cast<float>(globals::width);
     last_cursor.y = 0.5f * static_cast<float>(globals::height);
 
-    globals::dispatcher.sink<io::GlfwCursorPosEvent>().connect<&on_glfw_cursor_pos>();
-    globals::dispatcher.sink<io::GamepadButtonEvent>().connect<&on_gamepad_button>();
+    globals::dispatcher.sink<GlfwCursorPosEvent>().connect<&on_glfw_cursor_pos>();
+    globals::dispatcher.sink<GamepadButtonEvent>().connect<&on_gamepad_button>();
 }
 
-void entity::player_look::update_late(void)
+void player_look::update_late(void)
 {
-    if(io::gamepad::available && io::gamepad::active.get_value() && !globals::gui_screen) {
-        auto pitch_value = axis_pitch.get_value(io::gamepad::state, io::gamepad::deadzone.get_value());
-        auto yaw_value = axis_yaw.get_value(io::gamepad::state, io::gamepad::deadzone.get_value());
+    if(gamepad::available && gamepad::active.get_value() && !globals::gui_screen) {
+        auto pitch_value = axis_pitch.get_value(gamepad::state, gamepad::deadzone.get_value());
+        auto yaw_value = axis_yaw.get_value(gamepad::state, gamepad::deadzone.get_value());
 
         if(fastlook_enabled) {
             // Fastlook allows the camera to
diff --git a/src/game/client/entity/player_look.hh b/src/game/client/entity/player_look.hh
index 0ae18db..9d0f1dd 100644
--- a/src/game/client/entity/player_look.hh
+++ b/src/game/client/entity/player_look.hh
@@ -1,7 +1,7 @@
 #pragma once
 
-namespace entity::player_look
+namespace player_look
 {
 void init(void);
 void update_late(void);
-} // namespace entity::player_look
+} // namespace player_look
diff --git a/src/game/client/entity/player_move.cc b/src/game/client/entity/player_move.cc
index 4087b04..14d64cc 100644
--- a/src/game/client/entity/player_move.cc
+++ b/src/game/client/entity/player_move.cc
@@ -114,7 +114,7 @@ static glm::fvec3 pm_flight_move(const glm::fvec3& wishdir)
     return wishdir * PMOVE_MAX_SPEED_AIR;
 }
 
-void entity::player_move::init(void)
+void player_move::init(void)
 {
     movement_direction = ZERO_VEC3<float>;
 
@@ -153,14 +153,14 @@ void entity::player_move::init(void)
     settings::add_checkbox(2, enable_speedometer, settings_location::VIDEO_GUI, "player_move.enable_speedometer", true);
 }
 
-void entity::player_move::fixed_update(void)
+void player_move::fixed_update(void)
 {
-    const auto& head = globals::dimension->entities.get<entity::Head>(globals::player);
-    auto& transform = globals::dimension->entities.get<entity::Transform>(globals::player);
-    auto& velocity = globals::dimension->entities.get<entity::Velocity>(globals::player);
+    const auto& head = globals::dimension->entities.get<Head>(globals::player);
+    auto& transform = globals::dimension->entities.get<Transform>(globals::player);
+    auto& velocity = globals::dimension->entities.get<Velocity>(globals::player);
 
     // Interpolation - preserve current component states
-    globals::dimension->entities.emplace_or_replace<entity::client::TransformPrev>(globals::player, transform);
+    globals::dimension->entities.emplace_or_replace<client::TransformPrev>(globals::player, transform);
 
     glm::fvec3 forward, right;
     math::vectors(glm::fvec3(0.0f, head.angles[1], 0.0f), &forward, &right, nullptr);
@@ -175,7 +175,7 @@ void entity::player_move::fixed_update(void)
         return;
     }
 
-    auto grounded = globals::dimension->entities.try_get<entity::Grounded>(globals::player);
+    auto grounded = globals::dimension->entities.try_get<Grounded>(globals::player);
     auto velocity_horizontal = glm::fvec3(velocity.value.x, 0.0f, velocity.value.z);
 
     if(grounded) {
@@ -193,7 +193,7 @@ void entity::player_move::fixed_update(void)
         }
 
         if(footsteps_distance >= PMOVE_FOOTSTEP_SIZE) {
-            if(auto effect = world::voxel_sounds::get_footsteps(grounded->surface)) {
+            if(auto effect = voxel_sounds::get_footsteps(grounded->surface)) {
                 sound::play_player(effect, false, pitch_distrib(pitch_random));
             }
 
@@ -228,27 +228,27 @@ void entity::player_move::fixed_update(void)
             if(glm::abs(speed_change) < 0.01f) {
                 // No considerable speed increase within
                 // the precision we use to draw the speedometer
-                gui::status_lines::set(gui::STATUS_DEBUG, new_speed_text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f), 1.0f);
+                status_lines::set(STATUS_DEBUG, new_speed_text, ImVec4(0.7f, 0.7f, 0.7f, 1.0f), 1.0f);
             }
             else if(speed_change < 0.0f) {
                 // Speed change is negative, we are actively
                 // slowing down; use the red color for the status line
-                gui::status_lines::set(gui::STATUS_DEBUG, new_speed_text, ImVec4(1.0f, 0.0f, 0.0f, 1.0f), 1.0f);
+                status_lines::set(STATUS_DEBUG, new_speed_text, ImVec4(1.0f, 0.0f, 0.0f, 1.0f), 1.0f);
             }
             else {
                 // Speed change is positive, we are actively
                 // speeding up; use the green color for the status line
-                gui::status_lines::set(gui::STATUS_DEBUG, new_speed_text, ImVec4(0.0f, 1.0f, 0.0f, 1.0f), 1.0f);
+                status_lines::set(STATUS_DEBUG, new_speed_text, ImVec4(0.0f, 1.0f, 0.0f, 1.0f), 1.0f);
             }
         }
 
-        if(auto effect = world::voxel_sounds::get_footsteps(grounded->surface)) {
+        if(auto effect = voxel_sounds::get_footsteps(grounded->surface)) {
             sound::play_player(effect, false, 1.0f);
         }
     }
 }
 
-void entity::player_move::update_late(void)
+void player_move::update_late(void)
 {
     movement_direction = ZERO_VEC3<float>;
 
@@ -258,17 +258,17 @@ void entity::player_move::update_late(void)
         return;
     }
 
-    if(io::gamepad::available && io::gamepad::active.get_value()) {
-        if(button_move_down.is_pressed(io::gamepad::state)) {
+    if(gamepad::available && gamepad::active.get_value()) {
+        if(button_move_down.is_pressed(gamepad::state)) {
             movement_direction += DIR_DOWN<float>;
         }
 
-        if(button_move_up.is_pressed(io::gamepad::state)) {
+        if(button_move_up.is_pressed(gamepad::state)) {
             movement_direction += DIR_UP<float>;
         }
 
-        movement_direction.x += axis_move_sideways.get_value(io::gamepad::state, io::gamepad::deadzone.get_value());
-        movement_direction.z -= axis_move_forward.get_value(io::gamepad::state, io::gamepad::deadzone.get_value());
+        movement_direction.x += axis_move_sideways.get_value(gamepad::state, gamepad::deadzone.get_value());
+        movement_direction.z -= axis_move_forward.get_value(gamepad::state, gamepad::deadzone.get_value());
     }
     else {
         if(GLFW_PRESS == glfwGetKey(globals::window, key_move_forward.get_key())) {
diff --git a/src/game/client/entity/player_move.hh b/src/game/client/entity/player_move.hh
index 8c033cc..8516308 100644
--- a/src/game/client/entity/player_move.hh
+++ b/src/game/client/entity/player_move.hh
@@ -7,9 +7,9 @@ constexpr static float PMOVE_ACCELERATION_GROUND = 6.0f;
 constexpr static float PMOVE_FRICTION_GROUND = 10.0f;
 constexpr static float PMOVE_JUMP_FORCE = 0.275f;
 
-namespace entity::player_move
+namespace player_move
 {
 void init(void);
 void fixed_update(void);
 void update_late(void);
-} // namespace entity::player_move
+} // namespace player_move
diff --git a/src/game/client/entity/sound_emitter.cc b/src/game/client/entity/sound_emitter.cc
index 57909ec..79b5ab0 100644
--- a/src/game/client/entity/sound_emitter.cc
+++ b/src/game/client/entity/sound_emitter.cc
@@ -19,35 +19,35 @@
 
 #include "client/globals.hh"
 
-entity::SoundEmitter::SoundEmitter(void)
+SoundEmitter::SoundEmitter(void)
 {
     alGenSources(1, &source);
     sound = nullptr;
 }
 
-entity::SoundEmitter::~SoundEmitter(void)
+SoundEmitter::~SoundEmitter(void)
 {
     alSourceStop(source);
     alDeleteSources(1, &source);
 }
 
-void entity::SoundEmitter::update(void)
+void SoundEmitter::update(void)
 {
     if(globals::dimension) {
-        const auto view = globals::dimension->entities.view<entity::SoundEmitter>();
+        const auto view = globals::dimension->entities.view<SoundEmitter>();
 
-        const auto& pivot = entity::camera::position_chunk;
+        const auto& pivot = camera::position_chunk;
         const auto gain = glm::clamp(sound::volume_effects.get_value() * 0.01f, 0.0f, 1.0f);
 
         for(const auto [entity, emitter] : view.each()) {
             alSourcef(emitter.source, AL_GAIN, gain);
 
-            if(const auto transform = globals::dimension->entities.try_get<entity::client::TransformIntr>(entity)) {
+            if(const auto transform = globals::dimension->entities.try_get<client::TransformIntr>(entity)) {
                 auto position = coord::to_relative(pivot, transform->chunk, transform->local);
                 alSource3f(emitter.source, AL_POSITION, position.x, position.y, position.z);
             }
 
-            if(const auto velocity = globals::dimension->entities.try_get<entity::Velocity>(entity)) {
+            if(const auto velocity = globals::dimension->entities.try_get<Velocity>(entity)) {
                 alSource3f(emitter.source, AL_VELOCITY, velocity->value.x, velocity->value.y, velocity->value.z);
             }
 
diff --git a/src/game/client/entity/sound_emitter.hh b/src/game/client/entity/sound_emitter.hh
index 72a3f74..6bc0846 100644
--- a/src/game/client/entity/sound_emitter.hh
+++ b/src/game/client/entity/sound_emitter.hh
@@ -4,8 +4,6 @@
 
 struct SoundEffect;
 
-namespace entity
-{
 struct SoundEmitter final {
     resource_ptr<SoundEffect> sound;
     ALuint source;
@@ -17,4 +15,3 @@ public:
 public:
     static void update(void);
 };
-} // namespace entity
-- 
cgit