Working on cleanup

server/server.cpp

@@ -38,25 +38,18 @@ class Session : public std::enable_shared_from_this<Session> {
     websocket::stream<beast::tcp_stream> ws_;
     beast::flat_buffer buffer_;
     int id_;
-    //ClientState state_;
-    std::vector<ClientState> timedClientStates;
-
-   
+    
+	ClientStateInterval timedClientStates;
 
     void process_message(const std::string& msg) {
         auto now_server = std::chrono::system_clock::now();
 
         auto parts = split(msg, ':');
-        if (parts.empty()) return;
 
-        std::cout << msg << std::endl;
-
-        auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-            now_server.time_since_epoch()
-        ).count();
-
-        //Apply server delay:
-		now_ms -= SERVER_DELAY;
+        if (parts.size() < 16)
+        {
+            throw std::runtime_error("Unknown message type received, too small");
+        }
 
         uint64_t clientTimestamp = std::stoull(parts[1]);
 
@@ -64,51 +57,19 @@ class Session : public std::enable_shared_from_this<Session> {
 
         receivedState.id = id_;
 
-        /*
-        // Ñíà÷àëà ïðîãîíÿåì ñòàíäàðòíóþ ñèìóëÿöèþ "äî òåêóùåãî ìîìåíòà ñåðâåðà"
-        long long deltaMs = 0.0f;
-        if (state_.lastUpdateServerTime.time_since_epoch().count() > 0) {
-            deltaMs = (clientTimestamp - now_ms);
-        }
-
-
-        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)) };
         receivedState.lastUpdateServerTime = uptime_timepoint;
 
-
-        // Òåïåðü îáðàáàòûâàåì ñïåöèôèêó ñîîáùåíèÿ è ëàã
-        if (parts[0] == "ROT") {
-            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") {
-            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") {
+        if (parts[0] == "UPD") {
             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)
+        else
         {
-            timedClientStates.erase(timedClientStates.begin());
+			throw std::runtime_error("Unknown message type received: " + parts[0]);
         }
+
+		timedClientStates.add_state(receivedState);
     }
 
     void retranslateMessage(const std::string& msg)
@@ -131,12 +92,7 @@ public:
 
     void init()
     {
-        //state_.lastUpdateServerTime = std::chrono::system_clock::now();
     }
-    /*
-    std::string get_state_string() {
-        return state_.get_state_string(id_);
-	}*/
 
     void run() {
 
@@ -154,76 +110,6 @@ public:
             });
     }
 
-    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>(
-                now - state_.lastUpdateServerTime
-            ).count();
-        }
-
-        if (deltaMs > 0) {
-            state_.simulate_physics(deltaMs);
-            state_.lastUpdateServerTime = now; // Îáíîâëÿåì âðåìÿ ïîñëå ñèìóëÿöèè
-        }*/
-    }
-
     void send_message(std::string msg) {
         auto ss = std::make_shared<std::string>(std::move(msg));
         ws_.async_write(net::buffer(*ss), [ss](beast::error_code, std::size_t) {});
@@ -256,52 +142,13 @@ 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);
+    // TODO: Renew game state
 
-    /* {
-        std::lock_guard<std::mutex> lock(g_sessions_mutex);
-
-        // 1. Ñèìóëÿöèÿ ôèçèêè äëÿ âñåõ
-        for (auto& session : g_sessions) {
-            session->tick_physics_global(now);
-        }
-
-        static auto last_broadcast = now;
-        if (std::chrono::duration<float>(now - last_broadcast).count() >= 1.0f) {
-            last_broadcast = now;
-
-            auto now_ms = std::chrono::duration_cast<std::chrono::milliseconds>(
-                now.time_since_epoch()
-            ).count();
-            
-            // Ñîáèðàåì äàííûå âñåõ èãðîêîâ â îäèí ïàêåò
-            std::string snapshot = "WORLD_UPDATE|";
-			snapshot += std::to_string(now_ms) + "|";
-            snapshot += std::to_string(g_sessions.size()) + "|";
-            for (size_t i = 0; i < g_sessions.size(); ++i) {
-                if (g_sessions[i]->canFetchClientStateAtTime(now))
-                {
-                    snapshot += g_sessions[i]->fetchClientStateAtTime(now).get_state_string();
-                    if (i < g_sessions.size() - 1) snapshot += ";"; // Ðàçäåëèòåëü ìåæäó èãðîêàìè
-                }
-            }
-
-            // Ðàññûëàåì âñåì
-            for (auto& session : g_sessions) {
-                session->send_message(snapshot);
-            }
-        }
-        
-    }*/
-
-    // ÂÀÆÍÎ: Òèêàåì ÷àñòî (50ìñ), à øëåì äàííûå ðåäêî (1000ìñ âûøå)
     timer.expires_after(std::chrono::milliseconds(50));
     timer.async_wait([&](const boost::system::error_code& ec) {
         if (!ec) update_world(timer, ioc);
-        });
+    });
 }
 
 int main() {