From 88f68b20eaca507f58c1e9b66b95c4167f332ea4 Mon Sep 17 00:00:00 2001 From: Vlad Date: Mon, 2 Feb 2026 14:45:36 +0600 Subject: [PATCH 1/3] some fix --- server/server.cpp | 18 ++++++++----- src/Game.cpp | 47 +++++++++++++++++++++++++++++---- src/network/NetworkInterface.h | 4 ++- src/network/WebSocketClient.cpp | 10 ++++--- 4 files changed, 63 insertions(+), 16 deletions(-) diff --git a/server/server.cpp b/server/server.cpp index 463d04b..75d8874 100644 --- a/server/server.cpp +++ b/server/server.cpp @@ -82,7 +82,7 @@ class Session : public std::enable_shared_from_this { timedClientStates.add_state(receivedState); } else if (parts[0] == "FIRE") { - if (parts.size() < 8) { + if (parts.size() < 10) { std::cerr << "Invalid FIRE: too few parts\n"; return; } @@ -91,17 +91,19 @@ class Session : public std::enable_shared_from_this { Eigen::Vector3f pos{ std::stof(parts[2]), std::stof(parts[3]), std::stof(parts[4]) }; - Eigen::Vector3f dir{ - std::stof(parts[5]), std::stof(parts[6]), std::stof(parts[7]) + Eigen::Quaternion dir{ + std::stof(parts[5]), std::stof(parts[6]), std::stof(parts[7]), std::stof(parts[8]) }; - int shotCount = 1; - if (parts.size() >= 9) { + float velocity = std::stof(parts[9]); + + int shotCount = 2; + if (parts.size() >= 11) { try { - shotCount = std::stoi(parts[8]); + shotCount = std::stoi(parts[10]); } catch (...) { - shotCount = 1; + shotCount = 2; } } @@ -111,9 +113,11 @@ class Session : public std::enable_shared_from_this { std::to_string(pos.x()) + ":" + std::to_string(pos.y()) + ":" + std::to_string(pos.z()) + ":" + + std::to_string(dir.w()) + ":" + std::to_string(dir.x()) + ":" + std::to_string(dir.y()) + ":" + std::to_string(dir.z()) + ":" + + std::to_string(velocity) + ":" + std::to_string(shotCount); std::lock_guard lock(g_sessions_mutex); diff --git a/src/Game.cpp b/src/Game.cpp index 2e7aa41..6f50d2a 100644 --- a/src/Game.cpp +++ b/src/Game.cpp @@ -236,6 +236,7 @@ namespace ZL uint64_t now = SDL_GetTicks64(); if (now - lastProjectileFireTime >= static_cast(projectileCooldownMs)) { lastProjectileFireTime = now; + const float projectileSpeed = 60.0f; this->fireProjectiles(); @@ -245,15 +246,21 @@ namespace ZL Eigen::Vector3f centerPos = Environment::shipState.position + Environment::shipState.rotation * Vector3f{ 0, 0.9f, 5.0f }; + Eigen::Quaternionf q(Environment::shipState.rotation); + float speedToSend = projectileSpeed + Environment::shipState.velocity; + int shotCount = 2; + std::string fireMsg = "FIRE:" + std::to_string(now) + ":" + std::to_string(centerPos.x()) + ":" + std::to_string(centerPos.y()) + ":" + std::to_string(centerPos.z()) + ":" + - std::to_string(worldForward.x()) + ":" + - std::to_string(worldForward.y()) + ":" + - std::to_string(worldForward.z()) + ":" + - "2"; + std::to_string(q.w()) + ":" + + std::to_string(q.x()) + ":" + + std::to_string(q.y()) + ":" + + std::to_string(q.z()) + ":" + + std::to_string(speedToSend) + ":" + + std::to_string(shotCount); networkClient->Send(fireMsg); } @@ -1149,7 +1156,37 @@ namespace ZL const float projectileSpeed = 60.0f; const float lifeMs = 5000.0f; const float size = 0.5f; + for (const auto& pi : pending) { + const std::vector localOffsets = { + Vector3f{ -1.5f, 0.9f, 5.0f }, + Vector3f{ 1.5f, 0.9f, 5.0f } + //Vector3f{}, + //Vector3f{} + }; + Vector3f localForward = { 0, 0, -1 }; + Vector3f worldForward = pi.rotation * localForward; + + float len = worldForward.norm(); + if (len <= 1e-6f) { + continue; + } + worldForward /= len; + + Vector3f baseVel = worldForward * pi.velocity; + + for (const auto& off : localOffsets) { + Vector3f shotPos = pi.position + (pi.rotation * off); + + for (auto& p : projectiles) { + if (!p->isActive()) { + p->init(shotPos, baseVel, lifeMs, size, projectileTexture, renderer); + break; + } + } + } + } + /* auto remotePlayersSnapshot = networkClient->getRemotePlayers(); for (const auto& pi : pending) { Eigen::Vector3f dir = pi.direction; @@ -1190,7 +1227,7 @@ namespace ZL } } } - } + }*/ } } } diff --git a/src/network/NetworkInterface.h b/src/network/NetworkInterface.h index 6bb64be..fc03c53 100644 --- a/src/network/NetworkInterface.h +++ b/src/network/NetworkInterface.h @@ -11,7 +11,9 @@ namespace ZL { int shooterId = -1; uint64_t clientTime = 0; Eigen::Vector3f position = Eigen::Vector3f::Zero(); - Eigen::Vector3f direction = Eigen::Vector3f::Zero(); + //Eigen::Vector3f direction = Eigen::Vector3f::Zero(); + Eigen::Matrix3f rotation = Eigen::Matrix3f::Identity(); + float velocity = 0; }; class INetworkClient { diff --git a/src/network/WebSocketClient.cpp b/src/network/WebSocketClient.cpp index 047066b..6e6b7b8 100644 --- a/src/network/WebSocketClient.cpp +++ b/src/network/WebSocketClient.cpp @@ -128,7 +128,7 @@ namespace ZL { if (msg.rfind("PROJECTILE:", 0) == 0) { auto parts = split(msg, ':'); - if (parts.size() >= 9) { + if (parts.size() >= 10) { try { ProjectileInfo pi; pi.shooterId = std::stoi(parts[1]); @@ -138,11 +138,15 @@ namespace ZL { std::stof(parts[4]), std::stof(parts[5]) ); - pi.direction = Eigen::Vector3f( + Eigen::Quaternionf q( std::stof(parts[6]), std::stof(parts[7]), - std::stof(parts[8]) + std::stof(parts[8]), + std::stof(parts[9]) ); + pi.rotation = q.toRotationMatrix(); + + pi.velocity = std::stof(parts[10]); std::lock_guard pl(projMutex_); pendingProjectiles_.push_back(pi); } From 7b1d9363a043bae51e13a61a6b9b71951b940520 Mon Sep 17 00:00:00 2001 From: Vladislav Khorev Date: Thu, 5 Feb 2026 09:00:54 +0300 Subject: [PATCH 2/3] Fixing lag compensation and make more smooth --- proj-windows/CMakeLists.txt | 2 +- server/server.cpp | 92 ++++++++++++++++++++++++--------- src/Game.cpp | 75 +++++++++++++++++---------- src/Game.h | 3 +- src/network/ClientState.cpp | 12 ++++- src/network/WebSocketClient.cpp | 29 +++++++++++ 6 files changed, 159 insertions(+), 54 deletions(-) diff --git a/proj-windows/CMakeLists.txt b/proj-windows/CMakeLists.txt index 2355739..bc1a45f 100644 --- a/proj-windows/CMakeLists.txt +++ b/proj-windows/CMakeLists.txt @@ -81,7 +81,7 @@ target_compile_definitions(space-game001 PRIVATE PNG_ENABLED SDL_MAIN_HANDLED NETWORK - SIMPLIFIED +# SIMPLIFIED ) # Линкуем с SDL2main, если он вообще установлен diff --git a/server/server.cpp b/server/server.cpp index 75d8874..a8c978e 100644 --- a/server/server.cpp +++ b/server/server.cpp @@ -146,6 +146,7 @@ class Session : public std::enable_shared_from_this { } } + void sendBoxesToClient() { std::lock_guard lock(g_boxes_mutex); @@ -168,30 +169,6 @@ class Session : public std::enable_shared_from_this { send_message(boxMsg); } - void send_message(std::string msg) { - auto ss = std::make_shared(std::move(msg)); - - if (is_writing_) { - - ws_.async_write(net::buffer(*ss), - [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { - if (ec) { - std::cerr << "Write error: " << ec.message() << std::endl; - } - }); - } - else { - is_writing_ = true; - ws_.async_write(net::buffer(*ss), - [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { - self->is_writing_ = false; - if (ec) { - std::cerr << "Write error: " << ec.message() << std::endl; - } - }); - } - } - public: explicit Session(tcp::socket&& socket, int id) @@ -237,6 +214,46 @@ public: return id_; } + ClientState get_latest_state(std::chrono::system_clock::time_point now) { + if (timedClientStates.timedStates.empty()) { + return {}; + } + + // 1. Берем самое последнее известное состояние + ClientState latest = timedClientStates.timedStates.back(); + + // 3. Применяем компенсацию лага (экстраполяцию). + // Функция внутри использует simulate_physics, чтобы переместить объект + // из точки lastUpdateServerTime в точку now. + latest.apply_lag_compensation(now); + + return latest; + } + + void send_message(std::string msg) { + auto ss = std::make_shared(std::move(msg)); + + if (is_writing_) { + + ws_.async_write(net::buffer(*ss), + [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { + if (ec) { + std::cerr << "Write error: " << ec.message() << std::endl; + } + }); + } + else { + is_writing_ = true; + ws_.async_write(net::buffer(*ss), + [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { + self->is_writing_ = false; + if (ec) { + std::cerr << "Write error: " << ec.message() << std::endl; + } + }); + } + } + private: void do_read() { ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) { @@ -260,8 +277,33 @@ private: }; void update_world(net::steady_timer& timer, net::io_context& ioc) { + static auto last_snapshot_time = std::chrono::steady_clock::now(); + auto now = std::chrono::steady_clock::now(); - // TODO: Renew game state + // Рассылка Snapshot раз в 1000мс + /* + if (std::chrono::duration_cast(now - last_snapshot_time).count() >= 1000) { + last_snapshot_time = now; + + auto system_now = std::chrono::system_clock::now(); + + std::string snapshot_msg = "SNAPSHOT:" + std::to_string( + std::chrono::duration_cast( + system_now.time_since_epoch()).count() + ); + + std::lock_guard lock(g_sessions_mutex); + + // Формируем общую строку состояний всех игроков + for (auto& session : g_sessions) { + ClientState st = session->get_latest_state(system_now); + snapshot_msg += "|" + std::to_string(session->get_id()) + ":" + st.formPingMessageContent(); + } + + for (auto& session : g_sessions) { + session->send_message(snapshot_msg); + } + }*/ timer.expires_after(std::chrono::milliseconds(50)); timer.async_wait([&](const boost::system::error_code& ec) { diff --git a/src/Game.cpp b/src/Game.cpp index 42c843d..4848277 100644 --- a/src/Game.cpp +++ b/src/Game.cpp @@ -732,13 +732,13 @@ namespace ZL // Биндим текстуру корабля один раз для всех удаленных игроков (оптимизация батчинга) glBindTexture(GL_TEXTURE_2D, spaceshipTexture->getTexID()); - auto now = std::chrono::system_clock::now(); + /*auto now = std::chrono::system_clock::now(); //Apply server delay: now -= std::chrono::milliseconds(CLIENT_DELAY); latestRemotePlayers = networkClient->getRemotePlayers(); - + */ // Если сервер прислал коробки, применяем их однократно вместо локальной генерации if (!serverBoxesApplied && networkClient) { auto sboxes = networkClient->getServerBoxes(); @@ -761,15 +761,9 @@ namespace ZL } // Итерируемся по актуальным данным из extrapolateRemotePlayers - for (auto const& [id, remotePlayer] : latestRemotePlayers) { - - if (!remotePlayer.canFetchClientStateAtTime(now)) - { - continue; - } - - ClientState playerState = remotePlayer.fetchClientStateAtTime(now); + for (auto const& [id, remotePlayer] : remotePlayerStates) { + const ClientState& playerState = remotePlayer; renderer.PushMatrix(); renderer.LoadIdentity(); @@ -809,18 +803,15 @@ namespace ZL glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // Берем удаленных игроков - latestRemotePlayers = networkClient->getRemotePlayers(); + //latestRemotePlayers = networkClient->getRemotePlayers(); auto now = std::chrono::system_clock::now(); now -= std::chrono::milliseconds(CLIENT_DELAY); - for (auto const& [id, remotePlayer] : latestRemotePlayers) + for (auto const& [id, remotePlayer] : remotePlayerStates) { - if (!remotePlayer.canFetchClientStateAtTime(now)) - continue; - - ClientState st = remotePlayer.fetchClientStateAtTime(now); - + + const ClientState& st = remotePlayer; // Позиция корабля в мире Vector3f shipWorld = st.position; @@ -861,6 +852,9 @@ namespace ZL lastTickCount = std::chrono::duration_cast( std::chrono::system_clock::now().time_since_epoch() ).count(); + + lastTickCount = (lastTickCount / 50)*50; + return; } @@ -869,6 +863,8 @@ namespace ZL std::chrono::system_clock::now().time_since_epoch() ).count(); + newTickCount = (newTickCount / 50) * 50; + if (newTickCount - lastTickCount > CONST_TIMER_INTERVAL) { size_t delta = newTickCount - lastTickCount; @@ -882,15 +878,7 @@ namespace ZL sparkEmitter.update(static_cast(delta)); planetObject.update(static_cast(delta)); - static float pingTimer = 0.0f; - pingTimer += delta; - if (pingTimer >= 1000.0f) { - std::string pingMsg = "UPD:" + std::to_string(now_ms) + ":" + Environment::shipState.formPingMessageContent(); - networkClient->Send(pingMsg); - std::cout << "Sending: " << pingMsg << std::endl; - pingTimer = 0.0f; - } //Handle input: @@ -946,9 +934,44 @@ namespace ZL std::cout << "Sending: " << msg << std::endl; } - Environment::shipState.simulate_physics(delta); + long long leftoverDelta = delta; + while (leftoverDelta > 0) + { + long long miniDelta = 50; + Environment::shipState.simulate_physics(miniDelta); + leftoverDelta -= miniDelta; + } Environment::inverseShipMatrix = Environment::shipState.rotation.inverse(); + static float pingTimer = 0.0f; + pingTimer += delta; + if (pingTimer >= 1000.0f) { + std::string pingMsg = "UPD:" + std::to_string(now_ms) + ":" + Environment::shipState.formPingMessageContent(); + + networkClient->Send(pingMsg); + std::cout << "Sending: " << pingMsg << std::endl; + pingTimer = 0.0f; + } + + + auto latestRemotePlayers = networkClient->getRemotePlayers(); + + std::chrono::system_clock::time_point nowRounded{ std::chrono::milliseconds(newTickCount) }; + + + for (auto const& [id, remotePlayer] : latestRemotePlayers) { + + if (!remotePlayer.canFetchClientStateAtTime(nowRounded)) + { + continue; + } + + ClientState playerState = remotePlayer.fetchClientStateAtTime(nowRounded); + + remotePlayerStates[id] = playerState; + + } + for (auto& p : projectiles) { if (p && p->isActive()) { p->update(static_cast(delta), renderer); diff --git a/src/Game.h b/src/Game.h index 10177c4..b8b2ce6 100644 --- a/src/Game.h +++ b/src/Game.h @@ -73,7 +73,8 @@ namespace ZL { std::vector boxLabels; std::unique_ptr textRenderer; - std::unordered_map latestRemotePlayers; + //std::unordered_map latestRemotePlayers; + std::unordered_map remotePlayerStates; float newShipVelocity = 0; diff --git a/src/network/ClientState.cpp b/src/network/ClientState.cpp index 7de142d..8f52c0e 100644 --- a/src/network/ClientState.cpp +++ b/src/network/ClientState.cpp @@ -157,6 +157,16 @@ void ClientState::apply_lag_compensation(std::chrono::system_clock::time_point n deltaMs = std::chrono::duration_cast(nowTime - lastUpdateServerTime).count(); } + long long deltaMsLeftover = deltaMs; + + while (deltaMsLeftover > 0) + { + long long miniDelta = 50; + simulate_physics(miniDelta); + deltaMsLeftover -= miniDelta; + } + + /* // 3. Защита от слишком больших скачков (Clamp) // Если лаг более 500мс, ограничиваем его, чтобы избежать резких рывков long long final_lag_ms = deltaMs;//min(deltaMs, 500ll); @@ -165,7 +175,7 @@ void ClientState::apply_lag_compensation(std::chrono::system_clock::time_point n // Доматываем симуляцию на величину задержки // Мы предполагаем, что за это время параметры управления не менялись simulate_physics(final_lag_ms); - } + }*/ } void ClientState::handle_full_sync(const std::vector& parts, int startFrom) { diff --git a/src/network/WebSocketClient.cpp b/src/network/WebSocketClient.cpp index 6e6b7b8..91db004 100644 --- a/src/network/WebSocketClient.cpp +++ b/src/network/WebSocketClient.cpp @@ -202,6 +202,35 @@ namespace ZL { } } + if (msg.rfind("SNAPSHOT:", 0) == 0) { + auto mainParts = split(msg.substr(9), '|'); // Отсекаем "SNAPSHOT:" и делим по игрокам + if (mainParts.empty()) continue; + + uint64_t serverTimestamp = std::stoull(mainParts[0]); + std::chrono::system_clock::time_point serverTime{ std::chrono::milliseconds(serverTimestamp) }; + + for (size_t i = 1; i < mainParts.size(); ++i) { + auto playerParts = split(mainParts[i], ':'); + if (playerParts.size() < 15) continue; // ID + 14 полей ClientState + + int rId = std::stoi(playerParts[0]); + if (rId == clientId) continue; // Свое состояние игрок знает лучше всех (Client Side Prediction) + + ClientState remoteState; + remoteState.id = rId; + remoteState.lastUpdateServerTime = serverTime; + + // Используем твой handle_full_sync, начиная со 2-го индекса (пропускаем ID в playerParts) + remoteState.handle_full_sync(playerParts, 1); + + { + std::lock_guard pLock(playersMutex); + remotePlayers[rId].add_state(remoteState); + } + } + continue; + } + } } void WebSocketClient::Send(const std::string& message) { From ec156bd67993f03f5bdec9f2c2663a7be3eff8c1 Mon Sep 17 00:00:00 2001 From: Vlad Date: Thu, 5 Feb 2026 13:29:21 +0600 Subject: [PATCH 3/3] add sync projectiles --- server/server.cpp | 505 +++++++++++++++++++++----------- src/Game.cpp | 84 ++++++ src/Game.h | 3 +- src/network/LocalClient.h | 13 +- src/network/NetworkInterface.h | 49 ++-- src/network/WebSocketClient.cpp | 56 +++- src/network/WebSocketClient.h | 91 +++--- 7 files changed, 561 insertions(+), 240 deletions(-) diff --git a/server/server.cpp b/server/server.cpp index 75d8874..85fbe76 100644 --- a/server/server.cpp +++ b/server/server.cpp @@ -7,14 +7,30 @@ #include #include #include +#include +#include #include #define _USE_MATH_DEFINES #include #include "../src/network/ClientState.h" #include #include +#include +#include + +namespace beast = boost::beast; +namespace http = beast::http; +namespace websocket = beast::websocket; +namespace net = boost::asio; +using tcp = net::ip::tcp; + +struct DeathInfo { + int targetId = -1; + uint64_t serverTime = 0; + Eigen::Vector3f position = Eigen::Vector3f::Zero(); + int killerId = -1; +}; -// Вспомогательный split std::vector split(const std::string& s, char delimiter) { std::vector tokens; std::string token; @@ -25,125 +41,95 @@ std::vector split(const std::string& s, char delimiter) { 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; - struct ServerBox { Eigen::Vector3f position; Eigen::Matrix3f rotation; float collisionRadius = 2.0f; }; +struct Projectile { + int shooterId = -1; + uint64_t spawnMs = 0; + Eigen::Vector3f pos; + Eigen::Vector3f vel; + float lifeMs = 5000.0f; +}; + std::vector g_serverBoxes; std::mutex g_boxes_mutex; - -std::vector> g_sessions; +std::vector> g_sessions; std::mutex g_sessions_mutex; +std::vector g_projectiles; +std::mutex g_projectiles_mutex; + +std::unordered_set g_dead_players; +std::mutex g_dead_mutex; + +class Session; + +void broadcastToAll(const std::string& message); + class Session : public std::enable_shared_from_this { websocket::stream ws_; beast::flat_buffer buffer_; int id_; bool is_writing_ = false; + std::queue> writeQueue_; + std::mutex writeMutex_; +public: ClientStateInterval timedClientStates; - void process_message(const std::string& msg) { - auto now_server = std::chrono::system_clock::now(); - auto parts = split(msg, ':'); - - if (parts.empty()) { - std::cerr << "Empty message received\n"; - return; - } - - std::string type = parts[0]; - - if (type == "UPD") { - if (parts.size() < 16) { - std::cerr << "Invalid UPD message: too few parts (" << parts.size() << ")\n"; - return; - } - uint64_t clientTimestamp = std::stoull(parts[1]); - ClientState receivedState; - receivedState.id = id_; - std::chrono::system_clock::time_point uptime_timepoint{ - std::chrono::milliseconds(clientTimestamp) - }; - receivedState.lastUpdateServerTime = uptime_timepoint; - receivedState.handle_full_sync(parts, 2); - retranslateMessage(msg); - timedClientStates.add_state(receivedState); - } - else if (parts[0] == "FIRE") { - if (parts.size() < 10) { - std::cerr << "Invalid FIRE: too few parts\n"; - return; - } - - uint64_t clientTime = std::stoull(parts[1]); - Eigen::Vector3f pos{ - std::stof(parts[2]), std::stof(parts[3]), std::stof(parts[4]) - }; - Eigen::Quaternion dir{ - std::stof(parts[5]), std::stof(parts[6]), std::stof(parts[7]), std::stof(parts[8]) - }; - - float velocity = std::stof(parts[9]); - - int shotCount = 2; - if (parts.size() >= 11) { - try { - shotCount = std::stoi(parts[10]); - } - catch (...) { - shotCount = 2; - } - } - - std::string broadcast = "PROJECTILE:" + - std::to_string(id_) + ":" + - std::to_string(clientTime) + ":" + - std::to_string(pos.x()) + ":" + - std::to_string(pos.y()) + ":" + - std::to_string(pos.z()) + ":" + - std::to_string(dir.w()) + ":" + - std::to_string(dir.x()) + ":" + - std::to_string(dir.y()) + ":" + - std::to_string(dir.z()) + ":" + - std::to_string(velocity) + ":" + - std::to_string(shotCount); - - std::lock_guard lock(g_sessions_mutex); - std::cout << "Player " << id_ << " fired " << shotCount << " shots → broadcasting\n"; - - for (auto& session : g_sessions) { - if (session->get_id() != id_) { - session->send_message(broadcast); - } - } - } - else { - std::cerr << "Unknown message type: " << type << "\n"; - } + explicit Session(tcp::socket&& socket, int id) + : ws_(std::move(socket)), id_(id) { } - void retranslateMessage(const std::string& msg) - { - std::string event_msg = "EVENT:" + std::to_string(id_) + ":" + msg; + int get_id() const { return id_; } - std::lock_guard lock(g_sessions_mutex); - for (auto& session : g_sessions) { - if (session->get_id() != id_) { // Не шлем отправителю - session->send_message(event_msg); - } + bool fetchStateAtTime(std::chrono::system_clock::time_point targetTime, ClientState& outState) const { + if (timedClientStates.canFetchClientStateAtTime(targetTime)) { + outState = timedClientStates.fetchClientStateAtTime(targetTime); + return true; } + return false; + } + + void send_message(const std::string& msg) { + auto ss = std::make_shared(msg); + { + std::lock_guard lock(writeMutex_); + writeQueue_.push(ss); + } + doWrite(); + } + + void run() { + { + std::lock_guard 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(); + }); + } + +private: + void init() { + sendBoxesToClient(); + + auto timer = std::make_shared(ws_.get_executor()); + timer->expires_after(std::chrono::milliseconds(100)); + timer->async_wait([self = shared_from_this(), timer](const boost::system::error_code& ec) { + if (!ec) { + self->send_message("ID:" + std::to_string(self->id_)); + self->do_read(); + } + }); } void sendBoxesToClient() { @@ -161,92 +147,44 @@ class Session : public std::enable_shared_from_this { std::to_string(q.z()) + "|"; } - if (!boxMsg.empty() && boxMsg.back() == '|') { - boxMsg.pop_back(); - } + if (!boxMsg.empty() && boxMsg.back() == '|') boxMsg.pop_back(); send_message(boxMsg); } - void send_message(std::string msg) { - auto ss = std::make_shared(std::move(msg)); - - if (is_writing_) { - - ws_.async_write(net::buffer(*ss), - [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { - if (ec) { - std::cerr << "Write error: " << ec.message() << std::endl; - } - }); + void doWrite() { + std::lock_guard lock(writeMutex_); + if (is_writing_ || writeQueue_.empty()) { + return; } - else { - is_writing_ = true; - ws_.async_write(net::buffer(*ss), - [self = shared_from_this(), ss](beast::error_code ec, std::size_t) { + + is_writing_ = true; + auto message = writeQueue_.front(); + + ws_.async_write(net::buffer(*message), + [self = shared_from_this(), message](beast::error_code ec, std::size_t) { + if (ec) { + std::cerr << "Write error: " << ec.message() << std::endl; + return; + } + { + std::lock_guard lock(self->writeMutex_); + self->writeQueue_.pop(); self->is_writing_ = false; - if (ec) { - std::cerr << "Write error: " << ec.message() << std::endl; - } - }); - } - } - - -public: - explicit Session(tcp::socket&& socket, int id) - : ws_(std::move(socket)), id_(id) { - } - - void init() - { - sendBoxesToClient(); - - auto timer = std::make_shared(ws_.get_executor()); - timer->expires_after(std::chrono::milliseconds(100)); - timer->async_wait([self = shared_from_this(), timer](const boost::system::error_code& ec) { - if (!ec) { - self->send_message("ID:" + std::to_string(self->id_)); - self->do_read(); - } + } + self->doWrite(); }); } - void run() { - - { - std::lock_guard 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(); - }); - } - - /*void send_message(std::string msg) { - auto ss = std::make_shared(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) - { + if (ec) { std::lock_guard lock(g_sessions_mutex); g_sessions.erase(std::remove_if(g_sessions.begin(), g_sessions.end(), [self](const std::shared_ptr& session) { return session.get() == self.get(); }), g_sessions.end()); + std::cout << "Client " << self->id_ << " disconnected\n"; return; } @@ -257,15 +195,236 @@ private: self->do_read(); }); } + + void process_message(const std::string& msg) { + auto parts = split(msg, ':'); + + if (parts.empty()) return; + + std::string type = parts[0]; + + if (type == "UPD") { + { + std::lock_guard gd(g_dead_mutex); + if (g_dead_players.find(id_) != g_dead_players.end()) { + std::cout << "Server: Ignoring UPD from dead player " << id_ << std::endl; + return; + } + } + + if (parts.size() < 16) return; + uint64_t clientTimestamp = std::stoull(parts[1]); + ClientState receivedState; + receivedState.id = id_; + std::chrono::system_clock::time_point uptime_timepoint{ + std::chrono::milliseconds(clientTimestamp) + }; + receivedState.lastUpdateServerTime = uptime_timepoint; + receivedState.handle_full_sync(parts, 2); + timedClientStates.add_state(receivedState); + + retranslateMessage(msg); + } + else if (parts[0] == "RESPAWN") { + { + std::lock_guard gd(g_dead_mutex); + g_dead_players.erase(id_); + } + + std::string respawnMsg = "RESPAWN_ACK:" + std::to_string(id_); + broadcastToAll(respawnMsg); + + std::cout << "Server: Player " << id_ << " respawned\n"; + } + else if (parts[0] == "FIRE") { + if (parts.size() < 10) return; + + uint64_t clientTime = std::stoull(parts[1]); + Eigen::Vector3f pos{ + std::stof(parts[2]), std::stof(parts[3]), std::stof(parts[4]) + }; + Eigen::Quaternionf dir( + std::stof(parts[5]), std::stof(parts[6]), std::stof(parts[7]), std::stof(parts[8]) + ); + float velocity = std::stof(parts[9]); + + int shotCount = 2; + if (parts.size() >= 11) { + try { shotCount = std::stoi(parts[10]); } + catch (...) { shotCount = 2; } + } + + std::string broadcast = "PROJECTILE:" + + std::to_string(id_) + ":" + + std::to_string(clientTime) + ":" + + std::to_string(pos.x()) + ":" + + std::to_string(pos.y()) + ":" + + std::to_string(pos.z()) + ":" + + std::to_string(dir.w()) + ":" + + std::to_string(dir.x()) + ":" + + std::to_string(dir.y()) + ":" + + std::to_string(dir.z()) + ":" + + std::to_string(velocity); + + { + std::lock_guard lock(g_sessions_mutex); + for (auto& session : g_sessions) { + if (session->get_id() != id_) { + session->send_message(broadcast); + } + } + } + + { + const std::vector localOffsets = { + Eigen::Vector3f(-1.5f, 0.9f, 5.0f), + Eigen::Vector3f(1.5f, 0.9f, 5.0f) + }; + + uint64_t now_ms = std::chrono::duration_cast( + std::chrono::system_clock::now().time_since_epoch()).count(); + + std::lock_guard pl(g_projectiles_mutex); + for (int i = 0; i < std::min(shotCount, (int)localOffsets.size()); ++i) { + Projectile pr; + pr.shooterId = id_; + pr.spawnMs = now_ms; + Eigen::Vector3f shotPos = pos + dir.toRotationMatrix() * localOffsets[i]; + pr.pos = shotPos; + Eigen::Vector3f localForward(0.0f, 0.0f, -1.0f); + Eigen::Vector3f worldForward = dir.toRotationMatrix() * localForward; + float len = worldForward.norm(); + if (len > 1e-6f) worldForward /= len; + pr.vel = worldForward * velocity; + pr.lifeMs = 5000.0f; + g_projectiles.push_back(pr); + + std::cout << "Server: Created projectile from player " << id_ + << " at pos (" << shotPos.x() << ", " << shotPos.y() << ", " << shotPos.z() + << ") vel (" << pr.vel.x() << ", " << pr.vel.y() << ", " << pr.vel.z() << ")" << std::endl; + } + } + } + } + + void retranslateMessage(const std::string& msg) { + std::string event_msg = "EVENT:" + std::to_string(id_) + ":" + msg; + + std::lock_guard lock(g_sessions_mutex); + for (auto& session : g_sessions) { + if (session->get_id() != id_) { + session->send_message(event_msg); + } + } + } }; +void broadcastToAll(const std::string& message) { + std::lock_guard lock(g_sessions_mutex); + for (const auto& session : g_sessions) { + session->send_message(message); + } +} + void update_world(net::steady_timer& timer, net::io_context& ioc) { - - // TODO: Renew game state - - timer.expires_after(std::chrono::milliseconds(50)); + const std::chrono::milliseconds interval(50); + timer.expires_after(interval); timer.async_wait([&](const boost::system::error_code& ec) { - if (!ec) update_world(timer, ioc); + if (ec) return; + + auto now = std::chrono::system_clock::now(); + uint64_t now_ms = static_cast(std::chrono::duration_cast(now.time_since_epoch()).count()); + + std::vector deathEvents; + + { + std::lock_guard pl(g_projectiles_mutex); + std::vector indicesToRemove; + + float dt = 50.0f / 1000.0f; + + for (size_t i = 0; i < g_projectiles.size(); ++i) { + auto& pr = g_projectiles[i]; + + pr.pos += pr.vel * dt; + + if (now_ms > pr.spawnMs + static_cast(pr.lifeMs)) { + indicesToRemove.push_back(static_cast(i)); + continue; + } + + bool hitDetected = false; + + { + std::lock_guard lm(g_sessions_mutex); + std::lock_guard gd(g_dead_mutex); + + for (auto& session : g_sessions) { + int targetId = session->get_id(); + + if (targetId == pr.shooterId) continue; + if (g_dead_players.find(targetId) != g_dead_players.end()) continue; + + ClientState targetState; + if (!session->fetchStateAtTime(now, targetState)) continue; + + Eigen::Vector3f diff = pr.pos - targetState.position; + const float shipRadius = 15.0f; + const float projectileRadius = 1.5f; + float combinedRadius = shipRadius + projectileRadius; + + if (diff.squaredNorm() <= combinedRadius * combinedRadius) { + DeathInfo death; + death.targetId = targetId; + death.serverTime = now_ms; + death.position = pr.pos; + death.killerId = pr.shooterId; + + deathEvents.push_back(death); + g_dead_players.insert(targetId); + indicesToRemove.push_back(static_cast(i)); + hitDetected = true; + + std::cout << "Server: *** HIT DETECTED! ***" << std::endl; + std::cout << "Server: Projectile at (" + << pr.pos.x() << ", " << pr.pos.y() << ", " << pr.pos.z() + << ") hit player " << targetId << std::endl; + break; + } + } + } + + if (hitDetected) continue; + } + + if (!indicesToRemove.empty()) { + std::sort(indicesToRemove.rbegin(), indicesToRemove.rend()); + for (int idx : indicesToRemove) { + if (idx >= 0 && idx < (int)g_projectiles.size()) { + g_projectiles.erase(g_projectiles.begin() + idx); + } + } + } + } + + if (!deathEvents.empty()) { + for (const auto& death : deathEvents) { + std::string deadMsg = "DEAD:" + + std::to_string(death.serverTime) + ":" + + std::to_string(death.targetId) + ":" + + std::to_string(death.position.x()) + ":" + + std::to_string(death.position.y()) + ":" + + std::to_string(death.position.z()) + ":" + + std::to_string(death.killerId); + + broadcastToAll(deadMsg); + + std::cout << "Server: Sent DEAD event - Player " << death.targetId + << " killed by " << death.killerId << std::endl; + } + } + + update_world(timer, ioc); }); } @@ -318,7 +477,6 @@ std::vector generateServerBoxes(int count) { return boxes; } - int main() { try { { @@ -341,7 +499,6 @@ int main() { }); }; - net::steady_timer timer(ioc); update_world(timer, ioc); diff --git a/src/Game.cpp b/src/Game.cpp index 6f50d2a..d5a8b94 100644 --- a/src/Game.cpp +++ b/src/Game.cpp @@ -645,6 +645,11 @@ namespace ZL // Итерируемся по актуальным данным из extrapolateRemotePlayers for (auto const& [id, remotePlayer] : latestRemotePlayers) { + // если локально помечен как убитый — пропускаем рендер + if (deadRemotePlayers.find(id) != deadRemotePlayers.end()) { + continue; + } + if (!remotePlayer.canFetchClientStateAtTime(now)) { continue; @@ -842,11 +847,16 @@ namespace ZL if (!uiGameOverShown) { if (uiManager.pushMenuFromFile("resources/config/game_over.json", this->renderer, CONST_ZIP_FILE)) { uiManager.setButtonCallback("restartButton", [this](const std::string& name) { + + std::string respawnMsg = "RESPAWN:" + std::to_string(networkClient->GetClientId()); + networkClient->Send(respawnMsg); + this->shipAlive = true; this->gameOver = false; this->uiGameOverShown = false; this->showExplosion = false; this->explosionEmitter.setEmissionPoints(std::vector()); + this->deadRemotePlayers.clear(); Environment::shipState.position = Vector3f{ 0, 0, 45000.f }; Environment::shipState.velocity = 0.0f; @@ -1229,6 +1239,80 @@ namespace ZL } }*/ } + // Обработка событий смерти, присланных сервером + auto deaths = networkClient->getPendingDeaths(); + if (!deaths.empty()) { + int localId = networkClient->GetClientId(); + std::cout << "Client: Received " << deaths.size() << " death events" << std::endl; + + for (const auto& d : deaths) { + std::cout << "Client: Processing death - target=" << d.targetId + << ", killer=" << d.killerId << ", pos=(" + << d.position.x() << ", " << d.position.y() << ", " << d.position.z() << ")" << std::endl; + + showExplosion = true; + explosionEmitter.setUseWorldSpace(true); + explosionEmitter.setEmissionPoints(std::vector{ d.position }); + explosionEmitter.emit(); + lastExplosionTime = SDL_GetTicks64(); + std::cout << "Client: Explosion emitted at (" << d.position.x() << ", " + << d.position.y() << ", " << d.position.z() << ")" << std::endl; + + if (d.targetId == localId) { + std::cout << "Client: Local ship destroyed!" << std::endl; + shipAlive = false; + gameOver = true; + Environment::shipState.velocity = 0.0f; + + if (!uiGameOverShown) { + if (uiManager.pushMenuFromFile("resources/config/game_over.json", + this->renderer, CONST_ZIP_FILE)) { + uiManager.setButtonCallback("restartButton", [this](const std::string& name) { + std::cout << "Client: Restart button clicked, sending RESPAWN" << std::endl; + + std::string respawnMsg = "RESPAWN:" + std::to_string(networkClient->GetClientId()); + networkClient->Send(respawnMsg); + + this->shipAlive = true; + this->gameOver = false; + this->uiGameOverShown = false; + this->showExplosion = false; + this->explosionEmitter.setEmissionPoints(std::vector()); + this->deadRemotePlayers.clear(); + + Environment::shipState.position = Vector3f{ 0, 0, 45000.f }; + Environment::shipState.velocity = 0.0f; + Environment::shipState.rotation = Eigen::Matrix3f::Identity(); + Environment::inverseShipMatrix = Eigen::Matrix3f::Identity(); + Environment::zoom = DEFAULT_ZOOM; + Environment::tapDownHold = false; + + uiManager.popMenu(); + std::cerr << "Game restarted\n"; + }); + + uiManager.setButtonCallback("gameOverExitButton", [this](const std::string& name) { + Environment::exitGameLoop = true; + }); + + uiGameOverShown = true; + } + } + } + else { + deadRemotePlayers.insert(d.targetId); + std::cout << "Marked remote player " << d.targetId << " as dead" << std::endl; + } + } + } + + auto respawns = networkClient->getPendingRespawns(); + if (!respawns.empty()) { + for (const auto& respawnId : respawns) { + deadRemotePlayers.erase(respawnId); + std::cout << "Client: Remote player " << respawnId << " respawned, removed from dead list" << std::endl; + } + } } } diff --git a/src/Game.h b/src/Game.h index 8c91b4b..4b0a33f 100644 --- a/src/Game.h +++ b/src/Game.h @@ -10,7 +10,7 @@ #include "utils/TaskManager.h" #include "network/NetworkInterface.h" #include - +#include namespace ZL { @@ -105,6 +105,7 @@ namespace ZL { const uint64_t explosionDurationMs = 500; bool serverBoxesApplied = false; + std::unordered_set deadRemotePlayers; }; diff --git a/src/network/LocalClient.h b/src/network/LocalClient.h index c45c0c8..8d72353 100644 --- a/src/network/LocalClient.h +++ b/src/network/LocalClient.h @@ -1,6 +1,5 @@ #pragma once -// WebSocketClient.h #include "NetworkInterface.h" #include @@ -16,8 +15,8 @@ namespace ZL { void Send(const std::string& message) override; bool IsConnected() const override { return true; } - int GetClientId() const { return 1; } - std::vector getPendingProjectiles(); + int GetClientId() const override { return 1; } + std::vector getPendingProjectiles() override; std::unordered_map getRemotePlayers() override { return std::unordered_map(); @@ -26,5 +25,13 @@ namespace ZL { std::vector> getServerBoxes() override { return {}; } + + std::vector getPendingDeaths() override { + return {}; + } + + std::vector getPendingRespawns() override { + return {}; + } }; } \ No newline at end of file diff --git a/src/network/NetworkInterface.h b/src/network/NetworkInterface.h index fc03c53..063b666 100644 --- a/src/network/NetworkInterface.h +++ b/src/network/NetworkInterface.h @@ -7,26 +7,37 @@ // NetworkInterface.h - »нтерфейс дл¤ разных типов соединений namespace ZL { - struct ProjectileInfo { - int shooterId = -1; - uint64_t clientTime = 0; - Eigen::Vector3f position = Eigen::Vector3f::Zero(); - //Eigen::Vector3f direction = Eigen::Vector3f::Zero(); - Eigen::Matrix3f rotation = Eigen::Matrix3f::Identity(); - float velocity = 0; - }; + struct ProjectileInfo { + int shooterId = -1; + uint64_t clientTime = 0; + Eigen::Vector3f position = Eigen::Vector3f::Zero(); + //Eigen::Vector3f direction = Eigen::Vector3f::Zero(); + Eigen::Matrix3f rotation = Eigen::Matrix3f::Identity(); + float velocity = 0; + }; - class INetworkClient { - public: - virtual ~INetworkClient() = default; - virtual void Connect(const std::string& host, uint16_t port) = 0; - virtual void Send(const std::string& message) = 0; - virtual bool IsConnected() const = 0; - virtual void Poll() = 0; // ƒл¤ обработки вход¤щих пакетов - virtual std::unordered_map getRemotePlayers() = 0; + struct DeathInfo { + int targetId = -1; + uint64_t serverTime = 0; + Eigen::Vector3f position = Eigen::Vector3f::Zero(); + int killerId = -1; + }; - virtual std::vector> getServerBoxes() = 0; + class INetworkClient { + public: + virtual ~INetworkClient() = default; + virtual void Connect(const std::string& host, uint16_t port) = 0; + virtual void Send(const std::string& message) = 0; + virtual bool IsConnected() const = 0; + virtual void Poll() = 0; // ƒл¤ обработки вход¤щих пакетов + virtual std::unordered_map getRemotePlayers() = 0; - virtual std::vector getPendingProjectiles() = 0; - }; + virtual std::vector> getServerBoxes() = 0; + + virtual std::vector getPendingProjectiles() = 0; + + virtual std::vector getPendingDeaths() = 0; + virtual std::vector getPendingRespawns() = 0; + virtual int GetClientId() const { return -1; } + }; } diff --git a/src/network/WebSocketClient.cpp b/src/network/WebSocketClient.cpp index 6e6b7b8..794ea69 100644 --- a/src/network/WebSocketClient.cpp +++ b/src/network/WebSocketClient.cpp @@ -71,6 +71,20 @@ namespace ZL { return copy; } + std::vector WebSocketClient::getPendingDeaths() { + std::lock_guard lock(deathsMutex_); + auto copy = pendingDeaths_; + pendingDeaths_.clear(); + return copy; + } + + std::vector WebSocketClient::getPendingRespawns() { + std::lock_guard lock(respawnMutex_); + auto copy = pendingRespawns_; + pendingRespawns_.clear(); + return copy; + } + void WebSocketClient::Poll() { std::lock_guard lock(queueMutex); @@ -125,6 +139,25 @@ namespace ZL { } continue; } + if (msg.rfind("RESPAWN_ACK:", 0) == 0) { + auto parts = split(msg, ':'); + if (parts.size() >= 2) { + try { + int respawnedPlayerId = std::stoi(parts[1]); + { + std::lock_guard rLock(respawnMutex_); + pendingRespawns_.push_back(respawnedPlayerId); + } + { + std::lock_guard pLock(playersMutex); + remotePlayers.erase(respawnedPlayerId); + } + std::cout << "Client: Received RESPAWN_ACK for player " << respawnedPlayerId << std::endl; + } + catch (...) {} + } + continue; + } if (msg.rfind("PROJECTILE:", 0) == 0) { auto parts = split(msg, ':'); @@ -150,8 +183,29 @@ namespace ZL { std::lock_guard pl(projMutex_); pendingProjectiles_.push_back(pi); } - catch (...) { + catch (...) {} + } + continue; + } + + if (msg.rfind("DEAD:", 0) == 0) { + auto parts = split(msg, ':'); + if (parts.size() >= 7) { + try { + DeathInfo di; + di.serverTime = std::stoull(parts[1]); + di.targetId = std::stoi(parts[2]); + di.position = Eigen::Vector3f( + std::stof(parts[3]), + std::stof(parts[4]), + std::stof(parts[5]) + ); + di.killerId = std::stoi(parts[6]); + + std::lock_guard dl(deathsMutex_); + pendingDeaths_.push_back(di); } + catch (...) {} } continue; } diff --git a/src/network/WebSocketClient.h b/src/network/WebSocketClient.h index 093e008..451f25c 100644 --- a/src/network/WebSocketClient.h +++ b/src/network/WebSocketClient.h @@ -2,7 +2,6 @@ #ifdef NETWORK -// WebSocketClient.h #include "NetworkInterface.h" #include #include @@ -12,62 +11,70 @@ namespace ZL { - class WebSocketClient : public INetworkClient { - private: - // Переиспользуем io_context из TaskManager - boost::asio::io_context& ioc_; + class WebSocketClient : public INetworkClient { + private: + // Переиспользуем io_context из TaskManager + boost::asio::io_context& ioc_; - // Объекты переехали в члены класса - std::unique_ptr> ws_; - boost::beast::flat_buffer buffer_; + // Объекты переехали в члены класса + std::unique_ptr> ws_; + boost::beast::flat_buffer buffer_; - std::queue messageQueue; - std::mutex queueMutex; // Защита для messageQueue + std::queue messageQueue; + std::mutex queueMutex; // Защита для messageQueue - std::queue> writeQueue_; - bool isWriting_ = false; - std::mutex writeMutex_; // Отдельный мьютекс для очереди записи + std::queue> writeQueue_; + bool isWriting_ = false; + std::mutex writeMutex_; // Отдельный мьютекс для очереди записи - bool connected = false; - int clientId = -1; + bool connected = false; + int clientId = -1; - std::unordered_map remotePlayers; - std::mutex playersMutex; + std::unordered_map remotePlayers; + std::mutex playersMutex; - // Серверные коробки - std::vector> serverBoxes_; - std::mutex boxesMutex; + // Серверные коробки + std::vector> serverBoxes_; + std::mutex boxesMutex; - std::vector pendingProjectiles_; - std::mutex projMutex_; + std::vector pendingProjectiles_; + std::mutex projMutex_; - void startAsyncRead(); - void processIncomingMessage(const std::string& msg); + std::vector pendingDeaths_; + std::mutex deathsMutex_; - public: - explicit WebSocketClient(boost::asio::io_context& ioc) : ioc_(ioc) {} + std::vector pendingRespawns_; + std::mutex respawnMutex_; - void Connect(const std::string& host, uint16_t port) override; + void startAsyncRead(); + void processIncomingMessage(const std::string& msg); - void Poll() override; + public: + explicit WebSocketClient(boost::asio::io_context& ioc) : ioc_(ioc) {} - void Send(const std::string& message) override; - void doWrite(); + void Connect(const std::string& host, uint16_t port) override; - bool IsConnected() const override { return connected; } - int GetClientId() const { return clientId; } + void Poll() override; - std::unordered_map getRemotePlayers() override { - std::lock_guard lock(playersMutex); - return remotePlayers; - } + void Send(const std::string& message) override; + void doWrite(); - std::vector> getServerBoxes() override { - std::lock_guard lock(boxesMutex); - return serverBoxes_; - } + bool IsConnected() const override { return connected; } + int GetClientId() const override { return clientId; } - std::vector getPendingProjectiles() override; - }; + std::unordered_map getRemotePlayers() override { + std::lock_guard lock(playersMutex); + return remotePlayers; + } + + std::vector> getServerBoxes() override { + std::lock_guard lock(boxesMutex); + return serverBoxes_; + } + + std::vector getPendingProjectiles() override; + std::vector getPendingDeaths() override; + std::vector getPendingRespawns() override; + }; } #endif