refactor(gameplay): split world into client and server

Remove monolithic World, Player, Chunk classes. Introduce ClientWorld, ServerWorld, ClientPlayer, and related networked components. Add Abseil dependency for logging and checks. Rename old files to pre_remove_* and update all includes and references accordingly.

include/Cubed/app.hpp

@@ -1,8 +1,10 @@
 #pragma once
+#include "Cubed/gameplay/client_world.hpp"
+#include "Cubed/gameplay/network_server.hpp"
+#include "Cubed/gameplay/server_world.hpp"
 #define GLFW_INCLUDE_NONE
 #include "Cubed/camera.hpp"
 #include "Cubed/dev_panel.hpp"
-#include "Cubed/gameplay/world.hpp"
 #include "Cubed/renderer.hpp"
 #include "Cubed/texture_manager.hpp"
 #include "Cubed/window.hpp"
@@ -36,14 +38,19 @@ public:
     Renderer& renderer();
     TextureManager& texture_manager();
     Window& window();
-    World& world();
+    ClientWorld& client_world();
+    ServerWorld& server_world();
 
 private:
     Camera m_camera;
     TextureManager m_texture_manager;
-    World m_world;
+    NetworkServer m_server;
+    std::shared_ptr<NetworkClient> m_client;
+    ClientWorld m_client_world;
+
     DevPanel m_dev_panel{*this};
-    Renderer m_renderer{m_camera, m_world, m_texture_manager, m_dev_panel};
+    Renderer m_renderer{m_camera, m_client_world, m_texture_manager,
+                        m_dev_panel};
 
     Window m_window{m_renderer};
 

include/Cubed/camera.hpp

@@ -8,12 +8,12 @@
 
 namespace Cubed {
 
-class Player;
+class ClientPlayer;
 
 class Camera {
 private:
     bool m_firse_mouse = true;
-    Player* m_player;
+    ClientPlayer* m_player;
     float m_last_mouse_x, m_last_mouse_y;
     glm::vec3 m_camera_pos;
     bool m_under_water = false;
@@ -23,7 +23,7 @@ public:
 
     void update_move_camera();
 
-    void camera_init(Player* player);
+    void camera_init(ClientPlayer* player);
     void hot_reload();
     void reset_camera();
     void update_cursor_position_camera(double xpos, double ypos);

include/Cubed/dev_panel.hpp

@@ -5,7 +5,7 @@
 namespace Cubed {
 
 class App;
-class Player;
+class ClientPlayer;
 class DevPanel {
     struct ConfigView {
         float fov = 70.0f;
@@ -38,7 +38,7 @@ public:
 private:
     App& m_app;
     ConfigView m_config;
-    Player* m_player;
+    ClientPlayer* m_player;
     PlayerProfile m_player_profile;
     TextEditing m_text_editing;
     bool m_need_save_config = false;

include/Cubed/gameplay/client_player.hpp

@@ -14,7 +14,7 @@ enum class Gait { WALK = 0, RUN };
 class ClientWorld;
 class ClientPlayer {
 public:
-    ClientPlayer(ClientWorld& world, std::string_view name);
+    ClientPlayer(ClientWorld& world);
     ~ClientPlayer();
     AABB get_aabb() const;
     const glm::vec3& get_front() const;
@@ -52,6 +52,8 @@ public:
     const std::string& get_uuid() const;
     const std::string& get_name() const;
 
+    void init(std::string_view name);
+
 private:
     using enum GameMode;
     float m_max_walk_speed = DEFAULT_MAX_WALK_SPEED;
@@ -98,7 +100,7 @@ private:
     std::string m_uuid;
     ClientWorld& m_world;
 
-    std::shared_mutex m_player_pos_mutex;
+    mutable std::shared_mutex m_player_pos_mutex;
 
     bool ray_cast(const glm::vec3& start, const glm::vec3& dir,
                   glm::ivec3& block_pos, glm::vec3& normal,

include/Cubed/gameplay/client_world.hpp

@@ -12,10 +12,10 @@ namespace Cubed {
 
 class ClientWorld {
 public:
-    ClientWorld(std::string_view player_name,
-                std::shared_ptr<NetworkClient> client);
+    ClientWorld();
     ~ClientWorld();
-    void init();
+    void init(std::string_view player_name,
+              std::shared_ptr<NetworkClient> client);
     void update(float delta_time);
     const std::optional<LookBlock>&
     get_look_block_pos(const std::string& name) const;
@@ -36,6 +36,9 @@ public:
     void rendering_distance(int rendering_distance);
     void start_client_thread(std::string_view uuid);
     void stop_client_thread();
+
+    void hot_reload();
+
     std::vector<glm::vec4>& planes();
     std::vector<ChunkRenderSnapshot>& render_snapshots();
     glm::vec3 sunlight_dir() const;

include/Cubed/gameplay/network_client.hpp

@@ -13,7 +13,7 @@ public:
     NetworkClient(ClientWorld& world);
     ~NetworkClient();
     void close();
-    asio::awaitable<void> connect(std::string ip, int port);
+
     void send(Packet packet);
     void start(std::string ip, int port = 25530);
 
@@ -26,7 +26,9 @@ private:
     std::vector<char> m_read_buffer;
     std::deque<Packet> m_write_queue;
     asio::strand<asio::io_context::executor_type> m_strand;
+    asio::awaitable<void> connect(std::string ip, int port);
     asio::awaitable<void> read_loop();
+
     std::atomic<bool> m_closed{false};
 
     // ClientWorld is managed by App

include/Cubed/gameplay/network_server.hpp

@@ -16,8 +16,7 @@ public:
     void start_server();
 
     int port() const;
-
-    std::unordered_map<std::string, std::shared_ptr<Session>> m_session;
+    ServerWorld& server_world();
 
 private:
     asio::io_context m_io;
@@ -26,6 +25,7 @@ private:
     std::atomic<bool> m_stopped{false};
     ServerWorld m_world;
     std::mutex m_session_mutex;
+    std::unordered_map<std::string, std::shared_ptr<Session>> m_session;
     asio::awaitable<void> listen();
     void net_run();
 };

include/Cubed/gameplay/server_world.hpp

@@ -115,9 +115,9 @@ private:
     std::atomic<bool> m_tick_running{true};
     std::atomic<int> m_per_tick_time = DEFAULT_PER_TICK_TIME; // ms
 
-    std::shared_mutex m_chunks_mutex;
+    mutable std::shared_mutex m_chunks_mutex;
     std::shared_mutex m_new_chunk_mutex;
-    std::shared_mutex m_player_mutex;
+    mutable std::shared_mutex m_player_mutex;
     std::mutex m_need_gen_queue_mutex;
     std::condition_variable_any m_gen_cv;
 

include/Cubed/gameplay/session.hpp

@@ -13,7 +13,8 @@ class ServerWorld;
 class Session : public std::enable_shared_from_this<Session> {
 
 public:
-    Session(tcp::socket socket, ServerWorld& server_world);
+    Session(tcp::socket socket, ServerWorld& server_world,
+            asio::io_context& io);
     ~Session();
     void start();
     void send(Packet packet);

include/Cubed/gameplay/vertex_data.hpp

@@ -5,14 +5,14 @@
 #include <glad/glad.h>
 #include <vector>
 namespace Cubed {
-class World;
+class ClientWorld;
 struct VertexData {
     std::vector<Vertex3D> m_vertices;
     GLuint m_vbo = 0;
     GLuint m_vao = 0;
     std::atomic<std::size_t> m_sum{0};
-    World& m_world;
-    VertexData(World& world);
+    ClientWorld& m_world;
+    VertexData(ClientWorld& world);
     ~VertexData();
     VertexData(const VertexData&) = delete;
     VertexData(VertexData&&) noexcept;

include/Cubed/renderer.hpp

@@ -11,13 +11,13 @@ namespace Cubed {
 
 class Camera;
 class TextureManager;
-class World;
+class ClientWorld;
 class DevPanel;
 class Renderer {
 public:
     constexpr static int NUM_VAO = 7;
 
-    Renderer(const Camera& camera, World& world,
+    Renderer(const Camera& camera, ClientWorld& world,
              const TextureManager& texture_manager, DevPanel& dev_panel);
     ~Renderer();
     void hot_reload();
@@ -91,7 +91,7 @@ private:
     const Camera& m_camera;
     DevPanel& m_dev_panel;
     const TextureManager& m_texture_manager;
-    World& m_world;
+    ClientWorld& m_world;
 
     bool m_discard_tranparent = true;
     bool m_shader_on = true;