refactor: move server logic to WorldScene and refactor UI methods

include/Cubed/app.hpp

@@ -1,7 +1,5 @@
 #pragma once
 #include "Cubed/audio/audio_engine.hpp"
-#include "Cubed/gameplay/network_server.hpp"
-#include "Cubed/gameplay/server_world.hpp"
 #define GLFW_INCLUDE_NONE
 #include "Cubed/argument.hpp"
 #include "Cubed/config.hpp"
@@ -40,7 +38,7 @@ public:
     Renderer& renderer();
     TextureManager& texture_manager();
     Window& window();
-    ServerWorld& server_world();
+
     Config& config();
     const Argument& argument() const;
     AudioEngine& audio();
@@ -49,7 +47,7 @@ private:
     Config m_game_config;
 
     TextureManager m_texture_manager;
-    NetworkServer m_server;
+
     AudioEngine m_audio;
 
     Renderer m_renderer;

include/Cubed/scene/world_scene.hpp

@@ -3,6 +3,7 @@
 #include "Cubed/camera.hpp"
 #include "Cubed/dev_panel.hpp"
 #include "Cubed/gameplay/client_world.hpp"
+#include "Cubed/gameplay/network_server.hpp"
 #include "Cubed/scene/scene.hpp"
 #include "Cubed/ui/world_ui_manager.hpp"
 namespace Cubed {
@@ -26,11 +27,13 @@ public:
     Camera& camera();
     SceneManager& scene_manager();
     ClientWorld& client_world();
+    ServerWorld& server_world();
 
 private:
     SceneManager& m_scene_manager;
     DevPanel m_dev_panel;
     Camera m_camera;
+    NetworkServer m_server;
     std::shared_ptr<NetworkClient> m_client;
     ClientWorld m_client_world;
     WorldUIManager m_ui_manager;

include/Cubed/ui/button.hpp

@@ -16,9 +16,6 @@ public:
     Button& operator=(const Button&) = delete;
     Button& operator=(Button&&) = delete;
 
-    void render(Renderer& renderer) override;
-    void update(float dt) override;
-
     bool handle_mouse_move_event(const MouseMoveEvent& e) override;
     bool handle_mouse_button_event(const MouseButtonEvent& e) override;
     void set_window_size(int width, int height) override;
@@ -54,5 +51,8 @@ private:
     std::unique_ptr<Image> m_background;
     std::unique_ptr<Label> m_foreground;
     bool m_hovered = false;
+
+    void on_render(Renderer& renderer) override;
+    void on_update(float dt) override;
 };
 } // namespace Cubed

include/Cubed/ui/image.hpp

@@ -9,8 +9,6 @@ class TextureManager;
 class Image : public Widget {
 public:
     Image(Widget* parent);
-    void update(float dt) override;
-    void render(Renderer& renderer) override;
 
     Image& set_image(const std::string& path, TextureManager& texture_manager);
     float width() const override;
@@ -20,6 +18,8 @@ public:
     float scale() const;
 
 private:
+    void on_render(Renderer& renderer) override;
+
     const Texture* m_texture = nullptr;
     glm::vec2 m_pos{0.0f, 0.0f};
     float m_scale = 1.0f;

include/Cubed/ui/label.hpp

@@ -18,8 +18,6 @@ public:
 
     Label& set_color(Color color);
     Label& set_scale(float scale);
-    virtual void update(float dt) override;
-    virtual void render(Renderer& renderer) override;
 
     const UIVertexData& data() const;
 

include/Cubed/ui/rect.hpp

@@ -12,9 +12,6 @@ public:
     Rect(Widget* parent);
     ~Rect();
 
-    void update(float dt) override;
-    void render(Renderer& renderer) override;
-
     float width() const override;
     float height() const override;
     float alpha() const;
@@ -31,6 +28,9 @@ public:
     Color color() const;
 
 private:
+    void on_update(float dt) override;
+    void on_render(Renderer& renderer) override;
+
     Color m_color = Color::WHITE;
     float m_width = 0.0f;
     float m_height = 0.0f;

src/app.cpp

@@ -65,17 +65,12 @@ void App::init(int argc, char** argv) {
     glfwSetCharCallback(m_window.get_glfw_window(), char_callback);
 
     m_audio.init();
-
-    ChunkGenerator::init();
     BlockManager::init();
     m_renderer.init(m_argument.debug_on);
     Logger::info("Renderer Init Success");
     // MapTable::init_map();
     m_texture_manager.init_texture();
     Logger::info("Texture Load Success");
-    if (!m_argument.is_client) {
-        m_server.start_server(m_argument.port);
-    }
 
     m_scene_manager.request_push(SceneType::MAIN_MENU);
 
@@ -669,10 +664,6 @@ void App::run() {
         update();
         render();
     }
-
-    if (!m_argument.is_client) {
-        m_server.server_world().stop();
-    }
 }
 // static Gait player_gait = Gait::WALK;
 void App::update() {
@@ -733,6 +724,10 @@ void App::dispatch_event(const Event& e) {
         return;
     }
 
+    if (DebugCollector::get().handle_event(e)) {
+        return;
+    }
+
     if (m_scene_manager.handle_event(e)) {
         return;
     }
@@ -764,7 +759,7 @@ float App::get_fps() { return fps; }
 Renderer& App::renderer() { return m_renderer; }
 TextureManager& App::texture_manager() { return m_texture_manager; }
 Window& App::window() { return m_window; }
-ServerWorld& App::server_world() { return m_server.server_world(); }
+
 Config& App::config() { return m_game_config; }
 const Argument& App::argument() const { return m_argument; }
 AudioEngine& App::audio() { return m_audio; }

src/dev_panel.cpp

@@ -270,7 +270,7 @@ void DevPanel::show_biome_table_bar() {
 }
 
 void DevPanel::show_time_table_bar() {
-    ServerWorld& world = m_app.server_world();
+    ServerWorld& world = m_world_scene.server_world();
     ImGui::Text("Game Tick %llu", world.game_tick());
     ImGui::SameLine();
     ImGui::Text("Day Tick %llu", world.day_tick());
@@ -495,40 +495,42 @@ void DevPanel::show_server_world_table_bar() {
     ImGui::Text("ChunkGenerator Seed: %u", ChunkGenerator::seed());
 
     ImGui::Text("Pool Threads %d  Max Support Threads %d  Reserved Threads %d",
-                m_app.server_world().gen_pool_threads(),
-                m_app.server_world().max_threads(), RESERVED_THREADS);
+                m_world_scene.server_world().gen_pool_threads(),
+                m_world_scene.server_world().max_threads(), RESERVED_THREADS);
     ImGui::SliderInt("Set Pool Threads", &m_threads, 1,
-                     m_app.server_world().max_threads());
+                     m_world_scene.server_world().max_threads());
     ImGui::SameLine();
     if (ImGui::Button("Set")) {
-        m_app.server_world().change_pool_threads(
+        m_world_scene.server_world().change_pool_threads(
             ServerWorld::ThreadPoolKind::GEN, m_threads);
     }
-    if (m_threads > m_app.server_world().max_threads() - RESERVED_THREADS) {
+    if (m_threads >
+        m_world_scene.server_world().max_threads() - RESERVED_THREADS) {
         ImGui::TextColored(
             ImVec4(1.0f, 1.0f, 0.0f, 1.0f),
             "Waring: When the threads in the thread pool exceed \n(maximum "
             "threads minus reserved threads), \nit may cause stuttering.");
     }
 
-    m_chunk_style = m_app.server_world().chunk_load_style();
+    m_chunk_style = m_world_scene.server_world().chunk_load_style();
     if (ImGui::Combo("ChunkLoadStyle", &m_chunk_style, CHUNK_LOAD_STYLE,
                      IM_ARRAYSIZE(CHUNK_LOAD_STYLE))) {
-        m_app.server_world().set_chunk_load_style(m_chunk_style);
+        m_world_scene.server_world().set_chunk_load_style(m_chunk_style);
     }
 
     if (ImGui::Button("Request Chunk Build")) {
-        m_app.server_world().need_gen(m_player->get_uuid());
+        m_world_scene.server_world().need_gen(m_player->get_uuid());
     }
     ImGui::SameLine();
     if (ImGui::Checkbox("Gen Thread", &m_gen_thread_running)) {
         if (m_gen_thread_running) {
-            m_app.server_world().start_gen_thread();
+            m_world_scene.server_world().start_gen_thread();
         } else {
-            m_app.server_world().stop_gen_thread();
+            m_world_scene.server_world().stop_gen_thread();
         }
     }
-    ImGui::Text("Server Chunk Size %d", m_app.server_world().chunk_size());
+    ImGui::Text("Server Chunk Size %d",
+                m_world_scene.server_world().chunk_size());
 
     if (ImGui::BeginTabBar("World Settings")) {
         if (ImGui::BeginTabItem("Time")) {

src/scene/world_scene.cpp

@@ -61,6 +61,11 @@ bool WorldScene::handle_event(const Event& e) {
 }
 void WorldScene::on_enter() {
 
+    ChunkGenerator::init();
+
+    if (!m_argument.is_client) {
+        m_server.start_server(m_argument.port);
+    }
     m_client = std::make_shared<NetworkClient>(m_client_world);
 
     m_client->start(m_argument.ip, m_argument.port);
@@ -80,9 +85,14 @@ void WorldScene::on_leave() {
 
     m_scene_manager.app().window().set_camera(nullptr);
     m_scene_manager.app().window().set_game_running(false);
+
+    if (!m_argument.is_client) {
+        m_server.server_world().stop();
+    }
 }
 
 Camera& WorldScene::camera() { return m_camera; }
 SceneManager& WorldScene::scene_manager() { return m_scene_manager; }
 ClientWorld& WorldScene::client_world() { return m_client_world; }
+ServerWorld& WorldScene::server_world() { return m_server.server_world(); }
 } // namespace Cubed

src/ui/button.cpp

@@ -3,7 +3,7 @@
 namespace Cubed {
 Button::Button(Widget* parent) : Widget(parent) {}
 
-void Button::update(float dt) {
+void Button::on_update(float dt) {
     if (m_background) {
         m_background->update(dt);
     }
@@ -12,7 +12,7 @@ void Button::update(float dt) {
     }
 }
 
-void Button::render(Renderer& renderer) {
+void Button::on_render(Renderer& renderer) {
     if (m_background) {
         m_background->render(renderer);
     }
@@ -32,6 +32,10 @@ bool Button::handle_mouse_move_event(const MouseMoveEvent& e) {
     }
     m_hovered = false;
 
+    if (Widget::handle_mouse_move_event(e)) {
+        return true;
+    }
+
     return false;
 }
 bool Button::handle_mouse_button_event(const MouseButtonEvent& e) {
@@ -42,6 +46,11 @@ bool Button::handle_mouse_button_event(const MouseButtonEvent& e) {
             return true;
         }
     }
+
+    if (Widget::handle_mouse_button_event(e)) {
+        return true;
+    }
+
     return false;
 }
 
@@ -51,6 +60,7 @@ Button& Button::set_scale(float scale) {
 }
 void Button::set_window_size(int width, int height) {
     m_background->set_window_size(width, height);
+    Widget::set_window_size(width, height);
 }
 Widget& Button::set_anchor(Anchor anchor) {
     m_background->set_anchor(anchor);

src/ui/image.cpp

@@ -5,8 +5,8 @@
 
 namespace Cubed {
 Image::Image(Widget* parent) : Widget(parent) {}
-void Image::update(float) {}
-void Image::render(Renderer& renderer) { renderer.render_image(*this); }
+
+void Image::on_render(Renderer& renderer) { renderer.render_image(*this); }
 
 Image& Image::set_image(const std::string& path,
                         TextureManager& texture_manager) {

src/ui/label.cpp

@@ -19,12 +19,9 @@ Label& Label::set_scale(float scale) {
     m_scale = scale;
     return *this;
 }
-void Label::update(float dt) { on_update(dt); }
 
 void Label::on_update(float dt) { (void)dt; }
 
-void Label::render(Renderer& renderer) { on_render(renderer); }
-
 void Label::on_render(Renderer& renderer) { renderer.render_lable(*this); }
 
 void Label::update_vertices() {

src/ui/rect.cpp

@@ -8,7 +8,8 @@ Rect::Rect(Widget* parent)
       };
 
 Rect::~Rect() {}
-void Rect::update(float dt) {
+
+void Rect::on_update(float) {
     if (m_fill) {
         if (!m_parent) {
             m_width = m_window_width;
@@ -18,12 +19,8 @@ void Rect::update(float dt) {
             m_height = m_parent->height();
         }
     }
-    Widget::update(dt);
-}
-void Rect::render(Renderer& renderer) {
-    renderer.render_rect(*this);
-    Widget::render(renderer);
 }
+void Rect::on_render(Renderer& renderer) { renderer.render_rect(*this); }
 
 float Rect::width() const { return m_width * m_scale; }
 float Rect::height() const { return m_height * m_scale; }