Fixing bug, implementing delays, remove WORLD_UPDATE

server/server.cpp

@@ -6,6 +6,7 @@
 #include <memory>
 #include <vector>
 #include <mutex>
+#include <map>
 #include <Eigen/Dense>
 #define _USE_MATH_DEFINES
 #include <math.h>
@@ -37,7 +38,10 @@ class Session : public std::enable_shared_from_this<Session> {
     websocket::stream<beast::tcp_stream> ws_;
     beast::flat_buffer buffer_;
     int id_;
-    ClientState state_;
+    //ClientState state_;
+    std::vector<ClientState> timedClientStates;
+
+   
 
     void process_message(const std::string& msg) {
         auto now_server = std::chrono::system_clock::now();
@@ -51,8 +55,16 @@ class Session : public std::enable_shared_from_this<Session> {
             now_server.time_since_epoch()
         ).count();
 
+        //Apply server delay:
+		now_ms -= SERVER_DELAY;
+
         uint64_t clientTimestamp = std::stoull(parts[1]);
 
+        ClientState receivedState;
+
+        receivedState.id = id_;
+
+        /*
         // Ñíà÷àëà ïðîãîíÿåì ñòàíäàðòíóþ ñèìóëÿöèþ "äî òåêóùåãî ìîìåíòà ñåðâåðà"
         long long deltaMs = 0.0f;
         if (state_.lastUpdateServerTime.time_since_epoch().count() > 0) {
@@ -60,34 +72,42 @@ class Session : public std::enable_shared_from_this<Session> {
         }
 
 
-        if (deltaMs > 0) state_.simulate_physics(deltaMs);
+        if (deltaMs > 0) state_.simulate_physics(deltaMs);*/
 
         std::chrono::system_clock::time_point uptime_timepoint{ std::chrono::duration_cast<std::chrono::system_clock::time_point::duration>(std::chrono::milliseconds(clientTimestamp)) };
-        state_.lastUpdateServerTime = uptime_timepoint;
+        receivedState.lastUpdateServerTime = uptime_timepoint;
 
 
         // Òåïåðü îáðàáàòûâàåì ñïåöèôèêó ñîîáùåíèÿ è ëàã
         if (parts[0] == "ROT") {
-            state_.discreteAngle = std::stoi(parts[2]);
-            state_.discreteMag = std::stof(parts[3]);
-            state_.handle_full_sync(parts, 4);
-            std::cout << "ROT id = " << this->id_ << " discreteMag=" << state_.discreteMag << std::endl;
-            state_.apply_lag_compensation(now_server);
-            state_.lastUpdateServerTime = now_server;
+            receivedState.discreteAngle = std::stoi(parts[2]);
+            receivedState.discreteMag = std::stof(parts[3]);
+            receivedState.handle_full_sync(parts, 4);
+            //std::cout << "ROT id = " << this->id_ << " discreteMag=" << state_.discreteMag << std::endl;
+            //receivedState.apply_lag_compensation(now_server);
+            //receivedState.lastUpdateServerTime = now_server;
             retranslateMessage(msg);
         }
         else if (parts[0] == "VEL") {
-            state_.selectedVelocity = std::stoi(parts[2]);
-            state_.handle_full_sync(parts, 3);
-            state_.apply_lag_compensation(now_server);
-            state_.lastUpdateServerTime = now_server;
+            receivedState.selectedVelocity = std::stoi(parts[2]);
+            receivedState.handle_full_sync(parts, 3);
+            //receivedState.apply_lag_compensation(now_server);
+            //receivedState.lastUpdateServerTime = now_server;
             retranslateMessage(msg);
         }
         else if (parts[0] == "PING") {
-            state_.handle_full_sync(parts, 2);
-            std::cout << "PING id = " << this->id_ <<" discreteMag=" << state_.discreteMag << std::endl;
-            state_.apply_lag_compensation(now_server);     
-            state_.lastUpdateServerTime = now_server;
+            receivedState.handle_full_sync(parts, 2);
+            retranslateMessage(msg);
+            //receivedState.apply_lag_compensation(now_server);
+            //receivedState.lastUpdateServerTime = now_server;
+        }
+        timedClientStates.push_back(receivedState);
+
+		auto cutoff_time = now_server - std::chrono::milliseconds(CUTOFF_TIME);
+
+        while (timedClientStates.size() > 0 && timedClientStates[0].lastUpdateServerTime < cutoff_time)
+        {
+            timedClientStates.erase(timedClientStates.begin());
         }
     }
 
@@ -111,12 +131,12 @@ public:
 
     void init()
     {
-        state_.lastUpdateServerTime = std::chrono::system_clock::now();
+        //state_.lastUpdateServerTime = std::chrono::system_clock::now();
     }
-
+    /*
     std::string get_state_string() {
         return state_.get_state_string(id_);
-	}
+	}*/
 
     void run() {
 
@@ -134,9 +154,63 @@ public:
             });
     }
 
-    void tick_physics_global(std::chrono::system_clock::time_point now) {
-        long long deltaMs = 0;
+    bool canFetchClientStateAtTime(std::chrono::system_clock::time_point targetTime)
+    {
+        if (timedClientStates.empty())
+        {
+            return false;
+        }
+        if (timedClientStates[0].lastUpdateServerTime > targetTime)
+        {
+            return false;
+        }
 
+        return true;
+    }
+
+    ClientState fetchClientStateAtTime(std::chrono::system_clock::time_point targetTime) {
+
+        ClientState closestState;
+
+        if (timedClientStates.empty())
+        {
+            throw std::runtime_error("No timed client states available");
+            return closestState;
+        }
+        if (timedClientStates[0].lastUpdateServerTime > targetTime)
+        {
+            throw std::runtime_error("Found time but it is in future");
+            return closestState;
+        }
+        if (timedClientStates.size() == 1)
+        {
+            closestState = timedClientStates[0];
+            closestState.apply_lag_compensation(targetTime);
+            return closestState;
+        }
+
+
+        for (size_t i = 0; i < timedClientStates.size() - 1; ++i)
+        {
+            const auto& earlierState = timedClientStates[i];
+            const auto& laterState = timedClientStates[i + 1];
+            if (earlierState.lastUpdateServerTime <= targetTime && laterState.lastUpdateServerTime >= targetTime)
+            {
+                closestState = earlierState;
+                closestState.apply_lag_compensation(targetTime);
+                return closestState;
+            }
+        }
+
+        closestState = timedClientStates[timedClientStates.size() - 1];
+        closestState.apply_lag_compensation(targetTime);
+        return closestState;
+    }
+
+    void tick_physics_global(std::chrono::system_clock::time_point now) {
+        /*long long deltaMs = 0;
+
+        
         // Åñëè ýòî ñàìûé ïåðâûé òèê, ïðîñòî çàïîìèíàåì âðåìÿ
         if (state_.lastUpdateServerTime.time_since_epoch().count() > 0) {
             deltaMs = std::chrono::duration_cast<std::chrono::milliseconds>(
@@ -147,7 +221,7 @@ public:
         if (deltaMs > 0) {
             state_.simulate_physics(deltaMs);
             state_.lastUpdateServerTime = now; // Îáíîâëÿåì âðåìÿ ïîñëå ñèìóëÿöèè
-        }
+        }*/
     }
 
     void send_message(std::string msg) {
@@ -184,7 +258,10 @@ private:
 void update_world(net::steady_timer& timer, net::io_context& ioc) {
     auto now = std::chrono::system_clock::now();
 
-    {
+    //Apply server delay
+    now -= std::chrono::milliseconds(SERVER_DELAY);
+
+    /* {
         std::lock_guard<std::mutex> lock(g_sessions_mutex);
 
         // 1. Ñèìóëÿöèÿ ôèçèêè äëÿ âñåõ
@@ -197,7 +274,7 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) {
             last_broadcast = now;
 
             auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                std::chrono::system_clock::now().time_since_epoch()
+                now.time_since_epoch()
             ).count();
             
             // Ñîáèðàåì äàííûå âñåõ èãðîêîâ â îäèí ïàêåò
@@ -205,8 +282,11 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) {
 			snapshot += std::to_string(now_ms) + "|";
             snapshot += std::to_string(g_sessions.size()) + "|";
             for (size_t i = 0; i < g_sessions.size(); ++i) {
-                snapshot += g_sessions[i]->get_state_string();
-                if (i < g_sessions.size() - 1) snapshot += ";"; // Ðàçäåëèòåëü ìåæäó èãðîêàìè
+                if (g_sessions[i]->canFetchClientStateAtTime(now))
+                {
+                    snapshot += g_sessions[i]->fetchClientStateAtTime(now).get_state_string();
+                    if (i < g_sessions.size() - 1) snapshot += ";"; // Ðàçäåëèòåëü ìåæäó èãðîêàìè
+                }
             }
 
             // Ðàññûëàåì âñåì
@@ -215,7 +295,7 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) {
             }
         }
         
-    }
+    }*/
 
     // ÂÀÆÍÎ: Òèêàåì ÷àñòî (50ìñ), à øëåì äàííûå ðåäêî (1000ìñ âûøå)
     timer.expires_after(std::chrono::milliseconds(50));