Server changes

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/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>

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

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

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/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()
@@ -38,3 +41,8 @@ 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()
 {
-    ENetEvent event;
-    if (enet_host_service(client, &event, 5000) > 0 &&
-        event.type == ENET_EVENT_TYPE_CONNECT)
-    {
-        deerith_client_info("Connected to server");
-        return true;
+    return new_clients;
 }
 
-    else
+void deerith::flush_network_events()
 {
-        enet_peer_reset(client_peer);
-        deerith_client_error("Failed to connect to server");
-        return false;
+    ENetEvent event;
+    new_clients.clear();
+
+    int result = 1;
+    while ((result = enet_host_service(server, &event, 0)) > 0)
+    {
+        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

@@ -4,7 +4,7 @@
 #include <deerith/graphics/window.h>
 #include <deerith/graphics/primitive.h>
 #include <deerith/graphics/input.h>
-#include <deerith/universe/universe.h>
+#include <deerith/universe.h>
 #include <deerith/engine.h>
 
 #include <imgui/imgui.h>

sandbox/src/server/server.cpp

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