Refactor for simpler engine

deerith_engine_client/CMakeLists.txt

@@ -18,6 +18,8 @@ target_sources(DeerithClient
 )
 
 target_include_directories(DeerithClient
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
     PUBLIC
         ${CMAKE_CURRENT_SOURCE_DIR}/include
         ${IMGUI_INCLUDE_DIRS}

deerith_engine_client/include/deerith/universe.h

@@ -1,9 +1,11 @@
 #pragma once
+#include <deerith/core/universe.h>
 
 namespace deerith
 {
-    void begin_connection_to_universe(const char *address, int port);
+    bool connect_to_universe(const char *address, int port);
     void shutdown_universe();
 
     bool is_universe_running();
+    void render_universe();
 }

deerith_engine_client/src/engine.cpp

@@ -17,7 +17,7 @@ void deerith::init_engine()
     deerith_trace("init engine");
 }
 
-void deerith::shutdown_enigne()
+void deerith::shutdown_engine()
 {
     shutdown_executing_servers();
     shutdown_network();

deerith_engine_client/src/network/network.cpp

@@ -49,24 +49,34 @@ void deerith::flush_network_events()
     ENetEvent event;
     while (enet_host_service(client, &event, 0) > 0)
     {
+        switch (event.type)
+        {
+        case ENET_EVENT_TYPE_DISCONNECT:
+            event.peer->data = NULL;
+            break;
+
+        case ENET_EVENT_TYPE_RECEIVE:
+            enet_packet_destroy(event.packet);
+            break;
+
+        case ENET_EVENT_TYPE_NONE:
+            break;
+        }
     }
 }
 
 bool deerith::wait_till_connected_to_server()
 {
     ENetEvent event;
-    if (enet_host_service(client, &event, 5000) > 0 &&
+    if (enet_host_service(client, &event, 5000) > 0 && event.type == ENET_EVENT_TYPE_CONNECT)
-        event.type == ENET_EVENT_TYPE_CONNECT)
     {
-        deerith_trace("Connected to server");
+        deerith_trace("connected to server");
-
         return true;
     }
-
     else
     {
         enet_peer_reset(client_peer);
-        deerith_error("Failed to connect to server");
+        deerith_error("failed to connect to server");
         return false;
     }
 }

deerith_engine_client/src/universe/universe.cpp

@@ -1,33 +1,36 @@
+#include <deerith/engine.h>
 #include <deerith/universe.h>
-#include <deerith/core/log.h>
 #include <deerith/core/tick.h>
 
-#include "../network/network_internals.h"
+#include "network/network_internals.h"
 
 #include <thread>
 #include <memory>
 
 namespace deerith
 {
-    std::unique_ptr<std::thread> universe_thread = {};
+    std::unique_ptr<std::thread> universe_thread;
     std::atomic<bool> universe_running = false;
 
     void universe_simulation();
 }
 
-void deerith::begin_connection_to_universe(const char *address, int port)
+bool deerith::connect_to_universe(const char *address, int port)
 {
-    deerith_assert(!universe_running, "begin_connection_to_universe failed because there is a current running universe");
+    deerith_assert(!universe_running, "connect_to_universe failed because there is a current running universe");
-
-    if (universe_thread && universe_thread->joinable())
-        universe_thread->join();
-
-    universe_thread.reset();
 
+    shutdown_universe();
     connect_to_server(address, port);
 
+    if (!wait_till_connected_to_server())
+    {
+        deerith_error("engine was not able to connect to server");
+        return false;
+    }
+
     universe_running = true;
     universe_thread = std::make_unique<std::thread>(universe_simulation);
+    return true;
 }
 
 bool deerith::is_universe_running()
@@ -37,20 +40,15 @@ bool deerith::is_universe_running()
 
 void deerith::universe_simulation()
 {
-    bool connected = wait_till_connected_to_server();
-
-    if (connected)
-    {
     while (universe_running)
     {
         flush_network_events();
 
         wait_for_tick();
     }
-    }
 
-    deerith_trace("Universe stop");
     universe_running = false;
+    deerith_trace("universe shutdown");
 }
 
 void deerith::shutdown_universe()

deerith_engine_client/src/universe/universe_render.cpp

@@ -0,0 +1,5 @@
+#include <deerith/universe.h>
+
+void deerith::render_universe()
+{
+}

deerith_engine_core/include/deerith/core/universe.h

@@ -0,0 +1,6 @@
+#pragma once
+
+namespace deerith
+{
+
+}

deerith_engine_core/include/deerith/engine.h

@@ -1,7 +1,8 @@
 #pragma once
 #include <cstdint>
+#include <deerith/core/log.h>
+#include <deerith/core/core.h>
 
-// At
 #define UNIVERSE_SIMULATION_TICK_FREQ 50
 #define NETWORK_RELATIVE_TICK 2
 #define NETWORK_DELAY 10
@@ -9,8 +10,8 @@
 namespace deerith
 {
     void init_engine();
-    void shutdown_enigne();
+    void shutdown_engine();
 
-    void execute_server(const char *server_executable_path, int port);
+    bool execute_server(const char *server_executable_path, int port);
     void shutdown_executing_servers();
 }

deerith_engine_core/include/deerith/universe/universe_definition.h

@@ -1,9 +0,0 @@
-#pragma once
-#include <deerith/universe/user.h>
-#include <functional>
-
-namespace deerith
-{
-
-    void define_client_callback(std::function<void(user &)>);
-}

deerith_engine_core/include/deerith/universe/user.h

@@ -1,24 +0,0 @@
-#pragma once
-#include <deerith/network/sync_variable.h>
-
-#include <functional>
-#include <vector>
-
-namespace deerith
-{
-    class user_t
-    {
-    public:
-        void *user_data = nullptr;
-
-        void register_sync_variable(sync_variable_base_t *var);
-
-    private:
-        std::vector<sync_variable_base_t *> buffers;
-    };
-
-    using user_registration_function = std::function<void(user_t &)>;
-
-    void register_user_sync_variables_init_callback(user_registration_function);
-    void register_user_sync_variables_shutdown_callback(user_registration_function);
-}

deerith_engine_core/src/server_execution.cpp

@@ -12,19 +12,21 @@ namespace deerith
     std::vector<pid_t> executing_servers;
 }
 
-void deerith::execute_server(const char *server_executable_path, int port)
+bool deerith::execute_server(const char *server_executable_path, int port)
 {
     pid_t pid = fork();
 
     if (pid < 0)
     {
         deerith_error("execute_server fatal error");
+        return false;
     }
 
     if (pid > 0)
     {
         executing_servers.push_back(pid);
         deerith_trace("server created");
+        return true;
     }
     else
     {

deerith_engine_core/src/user.cpp

@@ -1,22 +0,0 @@
-#include <deerith/universe/user.h>
-
-namespace deerith
-{
-    user_registration_function user_sync_variables_init_function;
-    user_registration_function user_sync_variables_shutdown_function;
-}
-
-void deerith::register_user_sync_variables_init_callback(user_registration_function fn)
-{
-    user_sync_variables_init_function = fn;
-}
-
-void deerith::register_user_sync_variables_shutdown_callback(user_registration_function fn)
-{
-    user_sync_variables_shutdown_function = fn;
-}
-
-void deerith::user_t::register_sync_variable(sync_variable_base_t *var)
-{
-    buffers.push_back(var);
-}

deerith_engine_server/include/deerith/universe.h

@@ -1,8 +1,9 @@
 #pragma once
+#include <deerith/core/universe.h>
 
 namespace deerith
 {
-    void begin_universe(int port);
+    void run_universe(int port);
     void shutdown_universe();
 
     bool is_universe_running();

deerith_engine_server/src/core.cpp

@@ -18,7 +18,7 @@ void deerith::init_engine()
     deerith_trace("init server engine");
 }
 
-void deerith::shutdown_enigne()
+void deerith::shutdown_engine()
 {
     shutdown_network();
 

deerith_engine_server/src/universe.cpp

@@ -24,34 +24,33 @@ void deerith::handle_signal(int signal)
         running = false;
 }
 
-void deerith::begin_universe(int port)
+void deerith::run_universe(int port)
 {
     std::signal(SIGTERM, handle_signal);
 
-    bool init_result = init_server(port);
+    if (init_server(port))
-
-    if (init_result)
     {
+        deerith_trace("server init on port {}", port);
         while (running)
         {
             universe_simulation();
         }
     }
+    else
+    {
+        deerith_error("could not init server");
+    }
 }
 
 void deerith::universe_simulation()
 {
-    if (universe_tick % 2 == 0)
-    {
     flush_network_events();
 
     for (ENetPeer *new_client : get_new_clients())
     {
         create_client(new_client);
     }
-    }
 
-    universe_tick++;
     wait_for_tick();
 }
 

imgui.ini

@@ -1,8 +0,0 @@
-[Window][Debug##Default]
-Pos=60,60
-Size=400,400
-
-[Window][Context]
-Pos=60,60
-Size=483,321
-

sandbox/src/client/window.cpp

@@ -1,65 +0,0 @@
-#include "client/window.h"
-#include <deerith/core/log.h>
-
-#include <deerith/graphics/window.h>
-#include <deerith/graphics/primitive.h>
-#include <deerith/graphics/input.h>
-#include <deerith/universe.h>
-#include <deerith/engine.h>
-
-#include <imgui/imgui.h>
-
-glm::vec2 player_pos(5, 5);
-char net_address[16] = "127.0.0.1";
-int port = 8080;
-float vel = 1;
-
-void start_window_loop()
-{
-    deerith_assert(deerith::init_window() == 0, "Failed to init_window");
-
-    while (deerith::begin_window_display())
-    {
-        deerith::define_primitive_viewspace(glm::vec2(0, 0), glm::vec2(10 * deerith::get_window_aspect_ratio(), 10));
-
-        player_pos += deerith::get_joystick_axes(0, 0) * (vel / 60.0f);
-
-        deerith::define_primitive_color(glm::vec4(0.4f, 0.7f, 1.0f, 1));
-        deerith::draw_primitive_rectangle(player_pos - glm::vec2(0.5f, 0.5f), player_pos + glm::vec2(0.5f, 0.5f));
-
-        if (ImGui::Begin("Context"))
-        {
-            ImGui::SliderFloat("Velocity", &vel, 0, 4);
-
-            if (deerith::is_universe_running())
-            {
-                ImGui::Text("Universe running");
-            }
-            else
-            {
-                ImGui::InputText("Net Address", net_address, 16);
-                ImGui::InputInt("Net port", &port);
-
-                if (ImGui::Button("Connect"))
-                {
-                    deerith::begin_connection_to_universe(net_address, port);
-                }
-
-                if (ImGui::Button("Create server"))
-                {
-                    deerith::execute_server("./SandboxServer", 8080);
-                }
-
-                if (ImGui::Button("Close all servers"))
-                {
-                    deerith::shutdown_executing_servers();
-                }
-            }
-        }
-        ImGui::End();
-
-        deerith::finish_window_display();
-    }
-
-    deerith::shutdown_window();
-}

sandbox/src/client/window.h

@@ -1,3 +0,0 @@
-#pragma once
-
-void start_window_loop();

sandbox/src/runtime/main.cpp

@@ -1,29 +1,44 @@
 #include <deerith/engine.h>
-
+#include <deerith/universe.h>
-#include "runtime/user_definition.h"
+#include <thread>
 
 #ifdef DEERITH_CLIENT
-#include "client/window.h"
+#include <deerith/graphics/window.h>
-#endif
-
-#ifdef DEERITH_SERVER
-#include "server/server.h"
 #endif
 
 int main(int args_count, const char **args)
 {
     deerith::init_engine();
 
-    deerith::register_user_sync_variables_init_callback(user_sync_variables_init);
+#ifdef DEERITH_SERVER
-    deerith::register_user_sync_variables_shutdown_callback(user_sync_variables_init);
+    deerith::run_universe(8080);
+#endif
 
 #ifdef DEERITH_CLIENT
-    start_window_loop();
+    if (!deerith::execute_server("./SandboxServer", 8080))
+    {
+        deerith_error("could not start server");
+        deerith::shutdown_engine();
+        return 1;
+    }
+
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+
+    if (deerith::connect_to_universe("127.0.0.1", 8080))
+    {
+        deerith_assert(deerith::init_window() == 0, "Failed to init_window");
+
+        while (deerith::begin_window_display())
+        {
+            deerith::render_universe();
+
+            deerith::finish_window_display();
+        }
+
+        deerith::shutdown_window();
+    }
 #endif
 
-#ifdef DEERITH_SERVER
+    deerith::shutdown_executing_servers();
-    init_server();
+    deerith::shutdown_engine();
-#endif
-
-    deerith::shutdown_enigne();
 }

sandbox/src/runtime/user_definition.cpp

@@ -1,20 +0,0 @@
-#include "runtime/user_definition.h"
-
-#include <deerith/universe/user.h>
-#include <deerith/core/log.h>
-
-void user_sync_variables_init(deerith::user_t &user)
-{
-    deerith_trace("removing user data to new user");
-    sandbox_user_data_t *sandbox_user_data = new sandbox_user_data_t();
-
-    user.user_data = sandbox_user_data;
-    user.register_sync_variable(&sandbox_user_data->position_sync);
-}
-
-void user_sync_variables_shutdown(deerith::user_t &user)
-{
-    deerith_trace("removing user");
-    delete ((sandbox_user_data_t *)user.user_data);
-    user.user_data = nullptr;
-}

sandbox/src/runtime/user_definition.h

@@ -1,10 +0,0 @@
-#pragma once
-#include <deerith/universe/user.h>
-
-struct sandbox_user_data_t
-{
-    deerith::sync_variable_t<glm::vec2> position_sync;
-};
-
-void user_sync_variables_init(deerith::user_t &user);
-void user_sync_variables_shutdown(deerith::user_t &user);

sandbox/src/server/server.cpp

@@ -1,11 +0,0 @@
-#include <deerith/universe.h>
-#include "server/server.h"
-
-namespace deerith
-{
-}
-
-void init_server()
-{
-    deerith::begin_universe(8085);
-}

sandbox/src/server/server.h

@@ -1,3 +0,0 @@
-#pragma once
-
-void init_server();