Server changes

deerith_engine_client/CMakeLists.txt

@@ -23,6 +23,11 @@ target_include_directories(DeerithClient
         ${IMGUI_INCLUDE_DIRS}
 )
 
+target_include_directories(DeerithClient
+    PRIVATE
+        ${CMAKE_CURRENT_SOURCE_DIR}/src
+)
+
 target_link_libraries(DeerithClient
     PUBLIC
         DeerithCore

deerith_engine_client/include/deerith/universe.h

@@ -4,5 +4,6 @@ namespace deerith
 {
     void begin_connection_to_universe(const char *address, int port);
     void shutdown_universe();
+
     bool is_universe_running();
 }

deerith_engine_client/src/engine.cpp

@@ -0,0 +1,21 @@
+#include <deerith/engine.h>
+#include <deerith/core/core.h>
+
+#include "network/network_internals.h"
+
+namespace deerith
+{
+
+}
+
+void deerith::init_engine()
+{
+    init_deerith_core();
+    init_network();
+}
+
+void deerith::shutdown_enigne()
+{
+    shutdown_deerith_core();
+    shutdown_network();
+}

deerith_engine_client/src/graphics/window.cpp

@@ -1,7 +1,7 @@
 #include "deerith/graphics/window.h"
 #include "primitive_internals.h"
 #include "../network/network_internals.h"
-#include <deerith/universe/universe.h>
+#include <deerith/universe.h>
 
 #include <glad/gl.h>
 #include <GLFW/glfw3.h>
@@ -73,7 +73,6 @@ int deerith::init_window()
 
     init_primitives();
     init_imgui();
-    init_network();
 
     return 0;
 }

deerith_engine_client/src/network/network.cpp

@@ -44,6 +44,15 @@ void deerith::shutdown_network()
     enet_deinitialize();
 }
 
+void deerith::flush_network_events()
+{
+    ENetEvent event;
+    while (enet_host_service(client, &event, 0) > 0)
+    {
+        deerith_client_info("{}", (int)event.type);
+    }
+}
+
 bool deerith::wait_till_connected_to_server()
 {
     ENetEvent event;
@@ -51,6 +60,7 @@ bool deerith::wait_till_connected_to_server()
         event.type == ENET_EVENT_TYPE_CONNECT)
     {
         deerith_client_info("Connected to server");
+
         return true;
     }
 

deerith_engine_client/src/network/network_internals.h

@@ -7,4 +7,6 @@ namespace deerith
 
     void connect_to_server(const char *address, int port);
     bool wait_till_connected_to_server();
+
+    void flush_network_events();
 }

deerith_engine_client/src/universe/universe.cpp

@@ -1,5 +1,6 @@
-#include <deerith/universe/universe.h>
+#include <deerith/universe.h>
 #include <deerith/core/log.h>
+#include <deerith/core/tick.h>
 
 #include "../network/network_internals.h"
 
@@ -42,8 +43,9 @@ void deerith::universe_simulation()
     {
         while (universe_running)
         {
-            deerith_client_trace("another thread");
-            std::this_thread::sleep_for(std::chrono::milliseconds(100));
+            flush_network_events();
+
+            wait_for_tick();
         }
     }
 

deerith_engine_core/include/deerith/core/log.h

@@ -7,6 +7,7 @@ namespace deerith
 {
     spdlog::logger *get_core_logger();
     spdlog::logger *get_graphics_logger();
+    spdlog::logger *get_server_logger();
 } // namespace deerith
 
 #define deerith_core_trace(...) deerith::get_core_logger()->trace(__VA_ARGS__)
@@ -14,6 +15,11 @@ namespace deerith
 #define deerith_core_warn(...) deerith::get_core_logger()->warn(__VA_ARGS__)
 #define deerith_core_error(...) deerith::get_core_logger()->error(__VA_ARGS__)
 
+#define deerith_server_trace(...) deerith::get_server_logger()->trace(__VA_ARGS__)
+#define deerith_server_info(...) deerith::get_server_logger()->info(__VA_ARGS__)
+#define deerith_server_warn(...) deerith::get_server_logger()->warn(__VA_ARGS__)
+#define deerith_server_error(...) deerith::get_server_logger()->error(__VA_ARGS__)
+
 #define deerith_client_trace(...) deerith::get_graphics_logger()->trace(__VA_ARGS__)
 #define deerith_client_info(...) deerith::get_graphics_logger()->info(__VA_ARGS__)
 #define deerith_client_warn(...) deerith::get_graphics_logger()->warn(__VA_ARGS__)
@@ -32,3 +38,10 @@ namespace deerith
         deerith::get_graphics_logger()->error(__VA_ARGS__); \
         __builtin_trap();                                   \
     }
+
+#define deerith_server_assert(condition, ...)             \
+    if (!(condition))                                     \
+    {                                                     \
+        deerith::get_server_logger()->error(__VA_ARGS__); \
+        __builtin_trap();                                 \
+    }

deerith_engine_core/include/deerith/core/tick.h

@@ -2,7 +2,5 @@
 
 namespace deerith
 {
-    class Client
-    {
-    };
+    void wait_for_tick();
 }

deerith_engine_core/include/deerith/network/network.h

@@ -1,6 +0,0 @@
-#pragma once
-
-namespace deerith
-{
-    void connect_to_server();
-}

deerith_engine_core/include/deerith/universe_definition.h

@@ -0,0 +1,11 @@
+#pragma once
+#include <functional>
+
+namespace deerith
+{
+    class Client
+    {
+    };
+
+    void define_client_callback(std::function<void(Client)>);
+}

deerith_engine_core/include/deerith/world/world.h

@@ -1,9 +0,0 @@
-#pragma once
-#include <functional>
-
-namespace deerith
-{
-    using world_tick_function = std::function<void(int current_tick)>;
-
-    void set_world_tick_callback(world_tick_function *tick_function);
-}

deerith_engine_core/src/internal.h

@@ -4,4 +4,7 @@ namespace deerith
 {
     void init_log();
     void shutdown_log();
+
+    void init_network();
+    void shutdown_network();
 }

deerith_engine_core/src/log.cpp

@@ -7,6 +7,7 @@ namespace deerith
 {
     std::shared_ptr<spdlog::logger> core_logger;
     std::shared_ptr<spdlog::logger> graphics_logger;
+    std::shared_ptr<spdlog::logger> server_logger;
 
 }
 
@@ -16,9 +17,11 @@ void deerith::init_log()
 
     core_logger = spdlog::stdout_color_mt("core");
     graphics_logger = spdlog::stdout_color_mt("graphics");
+    server_logger = spdlog::stdout_color_mt("server");
 
     core_logger->set_level(spdlog::level::level_enum::trace);
     graphics_logger->set_level(spdlog::level::level_enum::trace);
+    server_logger->set_level(spdlog::level::level_enum::trace);
 }
 
 void deerith::shutdown_log()
@@ -37,4 +40,9 @@ spdlog::logger *deerith::get_core_logger()
 spdlog::logger *deerith::get_graphics_logger()
 {
     return graphics_logger.get();
+}
+
+spdlog::logger *deerith::get_server_logger()
+{
+    return server_logger.get();
 }

deerith_engine_core/src/tick.cpp

@@ -0,0 +1,33 @@
+#include <deerith/core/tick.h>
+
+#include <chrono>
+#include <thread>
+
+namespace deerith
+{
+
+}
+
+void deerith::wait_for_tick()
+{
+    using clock = std::chrono::steady_clock;
+
+    static auto last_tick = clock::now();
+
+    constexpr auto tick_duration = std::chrono::milliseconds(20);
+    constexpr auto sleep_interval = std::chrono::milliseconds(1);
+
+    const auto target = last_tick + tick_duration;
+
+    while (clock::now() < target)
+    {
+        const auto remaining = target - clock::now();
+
+        if (remaining > sleep_interval)
+            std::this_thread::sleep_for(sleep_interval);
+        else
+            std::this_thread::yield();
+    }
+
+    last_tick = clock::now();
+}

deerith_engine_server/include/deerith/universe.h

@@ -2,7 +2,7 @@
 
 namespace deerith
 {
-    void init_universe_serve(int port);
+    void begin_universe(int port);
     void shutdown_universe();
 
     bool is_universe_running();

deerith_engine_server/src/core.cpp

@@ -0,0 +1,21 @@
+#include <deerith/engine.h>
+#include <deerith/core/core.h>
+
+#include "network/network_internals.h"
+
+namespace deerith
+{
+
+}
+
+void deerith::init_engine()
+{
+    init_deerith_core();
+    init_network();
+}
+
+void deerith::shutdown_enigne()
+{
+    shutdown_network();
+    shutdown_deerith_core();
+}

deerith_engine_server/src/network/network.cpp

@@ -4,28 +4,27 @@
 #include <deerith/core/log.h>
 
 #include <thread>
+#include <vector>
 
 #include "network_internals.h"
 
 namespace deerith
 {
-    ENetHost *client;
-    ENetPeer *client_peer;
+    ENetHost *server;
+
+    std::vector<ENetPeer *> new_clients;
 }
 
-void deerith::connect_to_server(const char *address, int port)
+void deerith::init_server(int port)
 {
-    ENetAddress eaddress = {0};
-    eaddress.port = port;
+    ENetAddress address = {0};
 
-    int result = enet_address_set_host(&eaddress, address);
-    deerith_client_assert(result == 0, "connect_to_server invalid address");
+    address.host = ENET_HOST_ANY;
+    address.port = port;
 
-    client = enet_host_create(NULL, 1, 2, 0, 0);
-    deerith_client_assert(client, "connect_to_server failed to create host");
+    server = enet_host_create(&address, 32, 2, 0, 0);
 
-    client_peer = enet_host_connect(client, &eaddress, 2, 0);
-    deerith_client_assert(client_peer, "enet_host_connect failed on connect_to_server");
+    deerith_server_assert(server, "init_server failed");
 }
 
 int deerith::init_network()
@@ -44,20 +43,42 @@ void deerith::shutdown_network()
     enet_deinitialize();
 }
 
-bool deerith::wait_till_connected_to_server()
+std::vector<ENetPeer *> &deerith::get_new_clients()
+{
+    return new_clients;
+}
+
+void deerith::flush_network_events()
 {
     ENetEvent event;
-    if (enet_host_service(client, &event, 5000) > 0 &&
-        event.type == ENET_EVENT_TYPE_CONNECT)
-    {
-        deerith_client_info("Connected to server");
-        return true;
-    }
+    new_clients.clear();
 
-    else
+    int result = 1;
+    while ((result = enet_host_service(server, &event, 0)) > 0)
     {
-        enet_peer_reset(client_peer);
-        deerith_client_error("Failed to connect to server");
-        return false;
+        switch (event.type)
+        {
+        case ENET_EVENT_TYPE_CONNECT:
+            new_clients.push_back(event.peer);
+            break;
+
+        case ENET_EVENT_TYPE_DISCONNECT:
+            event.peer->data = NULL;
+            break;
+
+        case ENET_EVENT_TYPE_RECEIVE:
+            printf("A packet of length %lu containing %s was received from %s on channel %u.\n",
+                   event.packet->dataLength,
+                   event.packet->data,
+                   event.peer->data,
+                   event.channelID);
+
+            enet_packet_destroy(event.packet);
+            break;
+
+        case ENET_EVENT_TYPE_NONE:
+            break;
+        }
     }
-}
+    deerith_server_info("{} ", result);
+}

deerith_engine_server/src/network/network_internals.h

@@ -1,4 +1,6 @@
 #pragma once
+#include <enet/enet.h>
+#include <vector>
 
 namespace deerith
 {
@@ -6,4 +8,7 @@ namespace deerith
     void shutdown_network();
 
     void init_server(int port);
+    void flush_network_events();
+
+    std::vector<ENetPeer *> &get_new_clients();
 }

deerith_engine_server/src/universe.cpp

@@ -0,0 +1,46 @@
+#include <deerith/universe.h>
+#include <deerith/universe_definition.h>
+
+#include <deerith/core/tick.h>
+#include <deerith/core/log.h>
+#include "network/network_internals.h"
+
+namespace deerith
+{
+    int universe_tick = 0;
+    void universe_simulation();
+
+    void create_client(ENetPeer *peer);
+}
+
+void deerith::begin_universe(int port)
+{
+    init_server(port);
+    while (true)
+    {
+        universe_simulation();
+    }
+}
+
+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();
+}
+
+void deerith::create_client(ENetPeer *client)
+{
+    char enet_address[32];
+    enet_address_get_host_ip(&client->address, enet_address, 31);
+    deerith_server_info("A new client has connected : {}", enet_address);
+}

imgui.ini

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

sandbox/src/client/window.cpp

@@ -1,32 +1,22 @@
+#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/core/core.h>
-#include <deerith/universe/universe.h>
-#include <iostream>
-#include <math.h>
-#include <imgui.h>
+#include <deerith/universe.h>
+#include <deerith/engine.h>
 
-#include "deerith/core/log.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;
 
-int main(int args_count, const char **args)
+void start_window_loop()
 {
-    deerith::init_deerith_core();
-
-    deerith_core_trace("{}", args[0]);
-
-    int init_result = deerith::init_window();
-    if (init_result != 0)
-    {
-        return init_result;
-    }
+    deerith_client_assert(deerith::init_window() == 0, "Failed to init_window");
 
     while (deerith::begin_window_display())
     {
@@ -62,6 +52,4 @@ int main(int args_count, const char **args)
     }
 
     deerith::shutdown_window();
-    deerith::shutdown_deerith_core();
-    return 0;
 }

sandbox/src/client/window.h

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

sandbox/src/common/main.cpp

@@ -1,24 +1,24 @@
-
-#include <deerith/core/core.h>
-#include <deerith/core/log.h>
 #include <deerith/engine.h>
 
-#ifdef DEERITH_SERVER
-#include <client/
+#ifdef DEERITH_CLIENT
+#include "client/window.h"
 #endif
 
+#ifdef DEERITH_SERVER
+#include "server/server.h"
+#endif
+
+int main(int args_count, const char **args)
+{
+    deerith::init_engine();
+
 #ifdef DEERITH_CLIENT
+    start_window_loop();
 #endif
 
-int main()
-{
-    deerith::init_deerith_core();
-
-    int init_result = deerith::init_window();
-    if (init_result != 0)
-    {
-        return init_result;
-    }
+#ifdef DEERITH_SERVER
+    init_server();
+#endif
 
     deerith::shutdown_enigne();
 }

sandbox/src/server/main.cpp

@@ -1,13 +0,0 @@
-
-#include <deerith/core/core.h>
-#include <deerith/core/log.h>
-
-int main(int args_count, const char **args)
-{
-    deerith::init_deerith_core();
-
-    deerith_core_trace("Running server\n{}", args[0]);
-
-    deerith::shutdown_deerith_core();
-    return 0;
-}

sandbox/src/server/server.cpp

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

sandbox/src/server/server.h

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