space-game001/server/server.cpp

#include <boost/beast/core.hpp>
#include <boost/beast/websocket.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <mutex>
#include <map>
#include <Eigen/Dense>
#define _USE_MATH_DEFINES
#include <math.h>
#include "../src/network/ClientState.h"

// Âñïîìîãàòåëüíûé split
std::vector<std::string> split(const std::string& s, char delimiter) {
    std::vector<std::string> tokens;
    std::string token;
    std::istringstream tokenStream(s);
    while (std::getline(tokenStream, token, delimiter)) {
        tokens.push_back(token);
    }
    return tokens;
}

namespace beast = boost::beast;
namespace http = beast::http;
namespace websocket = beast::websocket;
namespace net = boost::asio;
using tcp = net::ip::tcp;

class Session;

std::vector<std::shared_ptr<Session>> g_sessions;
std::mutex g_sessions_mutex;

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;

   

    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;

        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) {
            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") {
            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());
        }
    }

    void retranslateMessage(const std::string& msg)
    {
        std::string event_msg = "EVENT:" + std::to_string(id_) + ":" + msg;

        std::lock_guard<std::mutex> lock(g_sessions_mutex);
        for (auto& session : g_sessions) {
            if (session->get_id() != id_) { // Íå øëåì îòïðàâèòåëþ
                session->send_message(event_msg);
            }
        }
    }
   

public:
    explicit Session(tcp::socket&& socket, int id)
        : ws_(std::move(socket)), id_(id) {
    }

    void init()
    {
        //state_.lastUpdateServerTime = std::chrono::system_clock::now();
    }
    /*
    std::string get_state_string() {
        return state_.get_state_string(id_);
	}*/

    void run() {

        {
            std::lock_guard<std::mutex> lock(g_sessions_mutex);
			g_sessions.push_back(shared_from_this());
        }

        ws_.async_accept([self = shared_from_this()](beast::error_code ec) {
            if (ec) return;
            std::cout << "Client " << self->id_ << " connected\n";
            self->init();
            self->send_message("ID:" + std::to_string(self->id_));
            self->do_read();
            });
    }

    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) {});
    }

    int get_id() const {
        return id_;
	}

private:
    void do_read() {
        ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) {
            if (ec)
            {
                std::lock_guard<std::mutex> lock(g_sessions_mutex);
                g_sessions.erase(std::remove_if(g_sessions.begin(), g_sessions.end(),
                    [self](const std::shared_ptr<Session>& session) {
                        return session.get() == self.get();
					}), g_sessions.end());
                return;
            }

            std::string msg = beast::buffers_to_string(self->buffer_.data());
            self->process_message(msg);

            self->buffer_.consume(self->buffer_.size());
            self->do_read();
            });
    }
};

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. Ñèìóëÿöèÿ ôèçèêè äëÿ âñåõ
        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() {
    try {
        net::io_context ioc;
        tcp::acceptor acceptor{ ioc, {tcp::v4(), 8080} };
        int next_id = 1000;

        std::cout << "Server started on port 8080...\n";

        auto do_accept = [&](auto& self_fn) -> void {
            acceptor.async_accept([&, self_fn](beast::error_code ec, tcp::socket socket) {
                if (!ec) {
                    std::make_shared<Session>(std::move(socket), next_id++)->run();
                }
                self_fn(self_fn);
                });
            };

        
        net::steady_timer timer(ioc);
        update_world(timer, ioc);

        do_accept(do_accept);
        ioc.run();
    }
    catch (std::exception const& e) {
        std::cerr << "Error: " << e.what() << std::endl;
    }
    return 0;
}