From 8528b4dc901bb484d4ff1370775ab00634b4bc0e Mon Sep 17 00:00:00 2001 From: Vladislav Khorev Date: Fri, 6 Mar 2026 19:08:55 +0300 Subject: [PATCH] Clean up server --- server/CMakeLists.txt | 1 + server/server.cpp | 871 ++++++++++++++++++------------------------ server/server.h | 137 +++++++ 3 files changed, 510 insertions(+), 499 deletions(-) create mode 100644 server/server.h diff --git a/server/CMakeLists.txt b/server/CMakeLists.txt index 641ed8d..2880449 100644 --- a/server/CMakeLists.txt +++ b/server/CMakeLists.txt @@ -26,6 +26,7 @@ add_subdirectory("${BOOST_SRC_DIR}/libs/predef" boost-predef-build EXCLUDE_FROM_ # Исполняемый файл сервера add_executable(Server +server.h server.cpp ../src/network/ClientState.h ../src/network/ClientState.cpp diff --git a/server/server.cpp b/server/server.cpp index 2a498b0..54168e2 100644 --- a/server/server.cpp +++ b/server/server.cpp @@ -1,44 +1,11 @@ -#include +#include "server.h" #include #include #include -#include -#include -#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; -static constexpr float kWorldZOffset = 45000.0f; -static const Eigen::Vector3f kWorldOffset(0.0f, 0.0f, kWorldZOffset); - -static constexpr float kShipRadius = 15.0f; -static constexpr float kSpawnShipMargin = 25.0f; -static constexpr float kSpawnBoxMargin = 15.0f; -static constexpr float kSpawnZJitter = 60.0f; - -Eigen::Vector3f PickSafeSpawnPos(int forPlayerId); - -struct DeathInfo { - int targetId = -1; - uint64_t serverTime = 0; - Eigen::Vector3f position = Eigen::Vector3f::Zero(); - int killerId = -1; -}; std::vector split(const std::string& s, char delimiter) { std::vector tokens; @@ -50,279 +17,292 @@ std::vector split(const std::string& s, char delimiter) { return tokens; } -struct ServerBox { - Eigen::Vector3f position; - Eigen::Matrix3f rotation; - float collisionRadius = 2.0f; - bool destroyed = false; -}; +Session::Session(Server& server, tcp::socket&& socket, int id) + : server_(server) + , ws_(std::move(socket)) + , id_(id) { +} -struct Projectile { - int shooterId = -1; - uint64_t spawnMs = 0; - Eigen::Vector3f pos; - Eigen::Vector3f vel; - float lifeMs = PROJECTILE_LIFE; -}; +int Session::get_id() const { return id_; } -struct BoxDestroyedInfo { - int boxIndex = -1; - uint64_t serverTime = 0; - Eigen::Vector3f position = Eigen::Vector3f::Zero(); - int destroyedBy = -1; -}; +bool Session::hasSpawnReserved() const { return hasReservedSpawn_; } +const Eigen::Vector3f& Session::reservedSpawn() const { return reservedSpawn_; } -std::vector g_boxDestructions; -std::mutex g_boxDestructions_mutex; - -std::vector g_serverBoxes; -std::mutex g_boxes_mutex; - -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; - bool joined_ = false; - - bool hasReservedSpawn_ = false; - Eigen::Vector3f reservedSpawn_ = Eigen::Vector3f(0.0f, 0.0f, kWorldZOffset); - - std::string nickname = "Player"; - int shipType = 0; - - explicit Session(tcp::socket&& socket, int id) - : ws_(std::move(socket)), id_(id) { +bool Session::fetchStateAtTime(std::chrono::system_clock::time_point targetTime, ClientState& outState) const { + if (timedClientStates.canFetchClientStateAtTime(targetTime)) { + outState = timedClientStates.fetchClientStateAtTime(targetTime); + return true; } + return false; +} - int get_id() const { return id_; } - - bool hasSpawnReserved() const { return hasReservedSpawn_; } - const Eigen::Vector3f& reservedSpawn() const { return reservedSpawn_; } - - 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(); - }); - } - - bool IsMessageValid(const std::string& fullMessage) { -#ifdef ENABLE_NETWORK_CHECKSUM - size_t hashPos = fullMessage.find("#hash:"); - if (hashPos == std::string::npos) { - return false; // Хеша нет, хотя он ожидался - } - - std::string originalContent = fullMessage.substr(0, hashPos); - std::string receivedHashStr = fullMessage.substr(hashPos + 6); // 6 — длина "#hash:" - - // Вычисляем ожидаемый хеш от контента - size_t expectedHash = fnv1a_hash(originalContent + NET_SECRET); - - std::stringstream ss; - ss << std::hex << expectedHash; - - return ss.str() == receivedHashStr; -#else - return true; // В режиме отладки пропускаем всё -#endif - } - -private: - - void sendBoxesToClient() { - std::lock_guard lock(g_boxes_mutex); - - std::string boxMsg = "BOXES:"; - bool first = true; - - for (size_t i = 0; i < g_serverBoxes.size(); ++i) { - const auto& box = g_serverBoxes[i]; - - if (box.destroyed) continue; - - Eigen::Quaternionf q(box.rotation); - - if (!first) boxMsg += "|"; - first = false; - - boxMsg += std::to_string(i) + ":" + - std::to_string(box.position.x()) + ":" + - std::to_string(box.position.y()) + ":" + - std::to_string(box.position.z()) + ":" + - std::to_string(q.w()) + ":" + - std::to_string(q.x()) + ":" + - std::to_string(q.y()) + ":" + - std::to_string(q.z()) + ":" + - "0"; - } - - // Если все коробки уничтожены — отправится просто "BOXES:" (это нормально) - send_message(boxMsg); - } - - -public: - - void init() +void Session::send_message(const std::string& msg) { + auto ss = std::make_shared(msg); { - 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) { - auto now_tp = std::chrono::system_clock::now(); - uint64_t now_ms = static_cast( - std::chrono::duration_cast(now_tp.time_since_epoch()).count()); - - self->send_message("ID:" + std::to_string(self->id_) + ":" + std::to_string(now_ms)); - self->do_read(); - } - }); - } - - 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 doWrite() { std::lock_guard lock(writeMutex_); - if (is_writing_ || writeQueue_.empty()) { - return; - } - - 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; - } - self->doWrite(); - }); + writeQueue_.push(ss); } -private: + doWrite(); +} - void do_read() { - ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) { - 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; - } - - std::string msg = beast::buffers_to_string(self->buffer_.data()); - self->process_message(msg); - - self->buffer_.consume(self->buffer_.size()); - self->do_read(); - }); +void Session::run() { + { + std::lock_guard lock(server_.g_sessions_mutex); + server_.g_sessions.push_back(shared_from_this()); } - void process_message(const std::string& msg) { - if (!IsMessageValid(msg)) { - std::cout << "[Security] Invalid packet hash. Dropping message: " << msg << std::endl; - return; - } - std::string cleanMessage = msg.substr(0, msg.find("#hash:")); + ws_.async_accept([self = shared_from_this()](beast::error_code ec) { + if (ec) return; + std::cout << "Client " << self->id_ << " connected\n"; + self->init(); + }); +} - std::cout << "Received from player " << id_ << ": " << cleanMessage << std::endl; - auto parts = split(cleanMessage, ':'); +bool Session::IsMessageValid(const std::string& fullMessage) { +#ifdef ENABLE_NETWORK_CHECKSUM + size_t hashPos = fullMessage.find("#hash:"); + if (hashPos == std::string::npos) { + return false; // Хеша нет, хотя он ожидался + } - if (parts.empty()) return; + std::string originalContent = fullMessage.substr(0, hashPos); + std::string receivedHashStr = fullMessage.substr(hashPos + 6); // 6 — длина "#hash:" - std::string type = parts[0]; + // Вычисляем ожидаемый хеш от контента + size_t expectedHash = fnv1a_hash(originalContent + NET_SECRET); - if (type == "JOIN") { - std::string nick = "Player"; - int sType = 0; - if (parts.size() >= 2) nick = parts[1]; - if (parts.size() >= 3) { - try { sType = std::stoi(parts[2]); } - catch (...) { sType = 0; } - } + std::stringstream ss; + ss << std::hex << expectedHash; - this->nickname = nick; - this->shipType = sType; - this->joined_ = true; + return ss.str() == receivedHashStr; +#else + return true; // В режиме отладки пропускаем всё +#endif +} +void Session::sendBoxesToClient() { + std::lock_guard lock(server_.g_boxes_mutex); + + std::string boxMsg = "BOXES:"; + bool first = true; + + for (size_t i = 0; i < server_.g_serverBoxes.size(); ++i) { + const auto& box = server_.g_serverBoxes[i]; + + if (box.destroyed) continue; + + Eigen::Quaternionf q(box.rotation); + + if (!first) boxMsg += "|"; + first = false; + + boxMsg += std::to_string(i) + ":" + + std::to_string(box.position.x()) + ":" + + std::to_string(box.position.y()) + ":" + + std::to_string(box.position.z()) + ":" + + std::to_string(q.w()) + ":" + + std::to_string(q.x()) + ":" + + std::to_string(q.y()) + ":" + + std::to_string(q.z()) + ":" + + "0"; + } + + send_message(boxMsg); +} + + +void Session::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) { auto now_tp = std::chrono::system_clock::now(); uint64_t now_ms = static_cast( std::chrono::duration_cast(now_tp.time_since_epoch()).count()); - Eigen::Vector3f spawnPos = PickSafeSpawnPos(id_); - this->hasReservedSpawn_ = true; - this->reservedSpawn_ = spawnPos; + self->send_message("ID:" + std::to_string(self->id_) + ":" + std::to_string(now_ms)); + self->do_read(); + } + }); +} + +ClientState Session::get_latest_state(std::chrono::system_clock::time_point now) { + if (timedClientStates.timedStates.empty()) { + return {}; + } + ClientState latest = timedClientStates.timedStates.back(); + latest.apply_lag_compensation(now); + + return latest; +} + +void Session::doWrite() { + std::lock_guard lock(writeMutex_); + if (is_writing_ || writeQueue_.empty()) { + return; + } + + 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; + } + self->doWrite(); + }); +} + +void Session::do_read() { + ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) { + if (ec) { + std::lock_guard lock(self->server_.g_sessions_mutex); + self->server_.g_sessions.erase(std::remove_if(self->server_.g_sessions.begin(), self->server_.g_sessions.end(), + [self](const std::shared_ptr& session) { + return session.get() == self.get(); + }), self->server_.g_sessions.end()); + std::cout << "Client " << self->id_ << " disconnected\n"; + 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 Session::process_message(const std::string& msg) { + if (!IsMessageValid(msg)) { + std::cout << "[Security] Invalid packet hash. Dropping message: " << msg << std::endl; + return; + } + std::string cleanMessage = msg.substr(0, msg.find("#hash:")); + + std::cout << "Received from player " << id_ << ": " << cleanMessage << std::endl; + auto parts = split(cleanMessage, ':'); + + if (parts.empty()) return; + + std::string type = parts[0]; + + if (type == "JOIN") { + std::string nick = "Player"; + int sType = 0; + if (parts.size() >= 2) nick = parts[1]; + if (parts.size() >= 3) { + try { sType = std::stoi(parts[2]); } + catch (...) { sType = 0; } + } + + this->nickname = nick; + this->shipType = sType; + this->joined_ = true; + + auto now_tp = std::chrono::system_clock::now(); + uint64_t now_ms = static_cast( + std::chrono::duration_cast(now_tp.time_since_epoch()).count()); + + Eigen::Vector3f spawnPos = server_.PickSafeSpawnPos(id_); + this->hasReservedSpawn_ = true; + this->reservedSpawn_ = spawnPos; + + ClientState st; + st.id = id_; + st.position = spawnPos; + st.rotation = Eigen::Matrix3f::Identity(); + st.currentAngularVelocity = Eigen::Vector3f::Zero(); + st.velocity = 0.0f; + st.selectedVelocity = 0; + st.discreteMag = 0.0f; + st.discreteAngle = -1; + st.lastUpdateServerTime = now_tp; + st.nickname = this->nickname; + st.shipType = this->shipType; + + timedClientStates.add_state(st); + + this->send_message( + "SPAWN:" + std::to_string(id_) + ":" + std::to_string(now_ms) + ":" + st.formPingMessageContent() + ); + + std::string eventMsg = + "EVENT:" + std::to_string(id_) + ":UPD:" + std::to_string(now_ms) + ":" + st.formPingMessageContent(); + + server_.broadcastToAllExceptId(eventMsg, id_); + + std::cout << "Server: Player " << id_ << " joined as [" << nick << "] shipType=" << sType << std::endl; + + std::string info = "PLAYERINFO:" + std::to_string(id_) + ":" + nick + ":" + std::to_string(sType); + server_.broadcastToAllExceptId(info, id_); + + { + std::lock_guard lock(server_.g_sessions_mutex); + for (auto& session : server_.g_sessions) { + if (session->get_id() == this->id_) continue; + std::string otherInfo = "PLAYERINFO:" + std::to_string(session->get_id()) + ":" + session->nickname + ":" + std::to_string(session->shipType); + + this->send_message(otherInfo); + } + } + } + else if (type == "UPD") { + if (!joined_) { + std::cout << "Server: Ignoring UPD before JOIN from " << id_ << std::endl; + return; + } + { + std::lock_guard gd(server_.g_dead_mutex); + if (server_.g_dead_players.find(id_) != server_.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); + receivedState.nickname = this->nickname; + receivedState.shipType = this->shipType; + timedClientStates.add_state(receivedState); + + } + else if (type == "RESPAWN") { + { + std::lock_guard gd(server_.g_dead_mutex); + server_.g_dead_players.erase(id_); + } + + { + auto now_tp = std::chrono::system_clock::now(); + uint64_t now_ms = static_cast(std::chrono::duration_cast(now_tp.time_since_epoch()).count()); ClientState st; st.id = id_; + + Eigen::Vector3f spawnPos = server_.PickSafeSpawnPos(id_); st.position = spawnPos; + + this->hasReservedSpawn_ = true; + this->reservedSpawn_ = spawnPos; + st.rotation = Eigen::Matrix3f::Identity(); st.currentAngularVelocity = Eigen::Vector3f::Zero(); st.velocity = 0.0f; @@ -334,188 +314,53 @@ private: st.shipType = this->shipType; timedClientStates.add_state(st); - this->send_message( "SPAWN:" + std::to_string(id_) + ":" + std::to_string(now_ms) + ":" + st.formPingMessageContent() ); + std::string respawnMsg = "RESPAWN_ACK:" + std::to_string(id_); + server_.broadcastToAll(respawnMsg); - std::string eventMsg = - "EVENT:" + std::to_string(id_) + ":UPD:" + std::to_string(now_ms) + ":" + st.formPingMessageContent(); + std::string playerInfo = "PLAYERINFO:" + std::to_string(id_) + ":" + st.nickname + ":" + std::to_string(st.shipType); + server_.broadcastToAll(playerInfo); - { - std::lock_guard lock(g_sessions_mutex); - for (auto& session : g_sessions) { - if (session->get_id() == id_) continue; - session->send_message(eventMsg); - } - } - std::cout << "Server: Player " << id_ << " joined as [" << nick << "] shipType=" << sType << std::endl; + std::string eventMsg = "EVENT:" + std::to_string(id_) + ":UPD:" + std::to_string(now_ms) + ":" + st.formPingMessageContent(); + server_.broadcastToAll(eventMsg); - std::string info = "PLAYERINFO:" + std::to_string(id_) + ":" + nick + ":" + std::to_string(sType); - - { - std::lock_guard lock(g_sessions_mutex); - for (auto& session : g_sessions) { - if (session->get_id() == this->id_) continue; - session->send_message(info); - } - } - { - std::lock_guard lock(g_sessions_mutex); - for (auto& session : g_sessions) { - if (session->get_id() == this->id_) continue; - std::string otherInfo = "PLAYERINFO:" + std::to_string(session->get_id()) + ":" + session->nickname + ":" + std::to_string(session->shipType); - - this->send_message(otherInfo); - } - } - } - else if (type == "UPD") { - if (!joined_) { - std::cout << "Server: Ignoring UPD before JOIN from " << id_ << std::endl; - return; - } - { - 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); - receivedState.nickname = this->nickname; - receivedState.shipType = this->shipType; - timedClientStates.add_state(receivedState); - - } - else if (type == "RESPAWN") { - { - std::lock_guard gd(g_dead_mutex); - g_dead_players.erase(id_); - } - - { - auto now_tp = std::chrono::system_clock::now(); - uint64_t now_ms = static_cast(std::chrono::duration_cast(now_tp.time_since_epoch()).count()); - - ClientState st; - st.id = id_; - - Eigen::Vector3f spawnPos = PickSafeSpawnPos(id_); - st.position = spawnPos; - - this->hasReservedSpawn_ = true; - this->reservedSpawn_ = spawnPos; - - st.rotation = Eigen::Matrix3f::Identity(); - st.currentAngularVelocity = Eigen::Vector3f::Zero(); - st.velocity = 0.0f; - st.selectedVelocity = 0; - st.discreteMag = 0.0f; - st.discreteAngle = -1; - st.lastUpdateServerTime = now_tp; - st.nickname = this->nickname; - st.shipType = this->shipType; - - timedClientStates.add_state(st); - this->send_message( - "SPAWN:" + std::to_string(id_) + ":" + std::to_string(now_ms) + ":" + st.formPingMessageContent() - ); - std::string respawnMsg = "RESPAWN_ACK:" + std::to_string(id_); - broadcastToAll(respawnMsg); - - std::string playerInfo = "PLAYERINFO:" + std::to_string(id_) + ":" + st.nickname + ":" + std::to_string(st.shipType); - broadcastToAll(playerInfo); - - std::string eventMsg = "EVENT:" + std::to_string(id_) + ":UPD:" + std::to_string(now_ms) + ":" + st.formPingMessageContent(); - broadcastToAll(eventMsg); - - std::cout << "Server: Player " << id_ << " respawned, broadcasted RESPAWN_ACK, PLAYERINFO and initial UPD\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 - 6.f, 5.0f), - Eigen::Vector3f(1.5f, 0.9f - 6.f, 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 = 15000.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; - } - } + std::cout << "Server: Player " << id_ << " respawned, broadcasted RESPAWN_ACK, PLAYERINFO and initial UPD\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]); -Eigen::Vector3f PickSafeSpawnPos(int forPlayerId) + 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); + + + server_.broadcastToAllExceptId(broadcast, id_); + + server_.createProjectile(id_, pos, dir, velocity); + } +} + +Eigen::Vector3f Server::PickSafeSpawnPos(int forPlayerId) { static thread_local std::mt19937 rng{ std::random_device{}() }; @@ -580,14 +425,54 @@ Eigen::Vector3f PickSafeSpawnPos(int forPlayerId) return Eigen::Vector3f(600.0f + a * 100.0f, -600.0f + b * 100.0f, kWorldZOffset); } -void broadcastToAll(const std::string& message) { +void Server::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) { +void Server::broadcastToAllExceptId(const std::string& message, int id) +{ + std::lock_guard lock(g_sessions_mutex); + for (auto& session : g_sessions) { + if (session->get_id() == id) continue; + session->send_message(message); + } +} + +void Server::createProjectile(int id, Eigen::Vector3f pos, Eigen::Quaternionf dir, float velocity) +{ + const std::vector localOffsets = { + Eigen::Vector3f(-1.5f, 0.9f - 6.f, 5.0f), + Eigen::Vector3f(1.5f, 0.9f - 6.f, 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 < 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 = 15000.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 Server::update_world() { static auto last_snapshot_time = std::chrono::system_clock::now(); @@ -595,26 +480,6 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) { uint64_t now_ms = static_cast( std::chrono::duration_cast(now.time_since_epoch()).count()); - // --- Snapshot every 500ms --- - /*if (std::chrono::duration_cast(now - last_snapshot_time).count() >= 500) { - last_snapshot_time = now; - - std::string snapshot_msg = "SNAPSHOT:" + std::to_string(now_ms); - - std::lock_guard lock(g_sessions_mutex); - for (auto& session : g_sessions) { - ClientState st = session->get_latest_state(now); - snapshot_msg += "|" + std::to_string(session->get_id()) + ":" + st.formPingMessageContent(); - } - for (auto& session : g_sessions) { - session->send_message(snapshot_msg); - } - }*/ - - // --- Tick: broadcast each player's latest state to all others (20Hz) --- - // Send the raw last-known state with its original timestamp, NOT an extrapolated one. - // Extrapolating here causes snap-back: if a player stops rotating, the server would - // keep sending over-rotated positions until the new state arrives, then B snaps back. { std::lock_guard lock(g_sessions_mutex); for (auto& sender : g_sessions) { @@ -834,13 +699,13 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) { // --- Schedule next tick in 50ms --- timer.expires_after(std::chrono::milliseconds(50)); - timer.async_wait([&timer, &ioc](const boost::system::error_code& ec) { + timer.async_wait([this](const boost::system::error_code& ec) { if (ec) return; - update_world(timer, ioc); + update_world(); }); } -std::vector generateServerBoxes(int count) { +std::vector Server::generateServerBoxes(int count) { std::vector boxes; std::random_device rd; std::mt19937 gen(rd()); @@ -889,34 +754,42 @@ std::vector generateServerBoxes(int count) { return boxes; } +Server::Server(tcp::acceptor& acceptor, net::io_context& ioc) + : acceptor_(acceptor) + , ioc_(ioc) + , timer(ioc_) +{ +} + +void Server::init() +{ + std::lock_guard lock(g_boxes_mutex); + g_serverBoxes = generateServerBoxes(50); + std::cout << "Generated " << g_serverBoxes.size() << " boxes on server\n"; +} + +void Server::accept() +{ + acceptor_.async_accept([&](beast::error_code ec, tcp::socket socket) { + if (!ec) { + std::make_shared(*this, std::move(socket), next_id++)->run(); + } + accept(); + }); +} + int main() { try { - { - std::lock_guard lock(g_boxes_mutex); - g_serverBoxes = generateServerBoxes(50); - //g_serverBoxes = generateServerBoxes(1); - std::cout << "Generated " << g_serverBoxes.size() << " boxes on server\n"; - } net::io_context ioc; tcp::acceptor acceptor{ ioc, {tcp::v4(), 8081} }; - int next_id = 1000; + Server server(acceptor, ioc); + + server.accept(); std::cout << "Server started on port 8081...\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(std::move(socket), next_id++)->run(); - } - self_fn(self_fn); - }); - }; - - net::steady_timer timer(ioc); - update_world(timer, ioc); - - do_accept(do_accept); + server.update_world(); ioc.run(); } catch (std::exception const& e) { diff --git a/server/server.h b/server/server.h new file mode 100644 index 0000000..fbeca04 --- /dev/null +++ b/server/server.h @@ -0,0 +1,137 @@ +#pragma once +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "../src/network/ClientState.h" +#define _USE_MATH_DEFINES +#include + +namespace beast = boost::beast; +namespace http = beast::http; +namespace websocket = beast::websocket; +namespace net = boost::asio; +using tcp = net::ip::tcp; +static constexpr float kWorldZOffset = 45000.0f; +static const Eigen::Vector3f kWorldOffset(0.0f, 0.0f, kWorldZOffset); + +static constexpr float kShipRadius = 15.0f; +static constexpr float kSpawnShipMargin = 25.0f; +static constexpr float kSpawnBoxMargin = 15.0f; +static constexpr float kSpawnZJitter = 60.0f; + +std::vector split(const std::string& s, char delimiter); + +struct DeathInfo { + int targetId = -1; + uint64_t serverTime = 0; + Eigen::Vector3f position = Eigen::Vector3f::Zero(); + int killerId = -1; +}; + + +struct ServerBox { + Eigen::Vector3f position; + Eigen::Matrix3f rotation; + float collisionRadius = 2.0f; + bool destroyed = false; +}; + +struct Projectile { + int shooterId = -1; + uint64_t spawnMs = 0; + Eigen::Vector3f pos; + Eigen::Vector3f vel; + float lifeMs = PROJECTILE_LIFE; +}; + +struct BoxDestroyedInfo { + int boxIndex = -1; + uint64_t serverTime = 0; + Eigen::Vector3f position = Eigen::Vector3f::Zero(); + int destroyedBy = -1; +}; + +class Server; + +class Session : public std::enable_shared_from_this { + Server& server_; + websocket::stream ws_; + beast::flat_buffer buffer_; + int id_; + bool is_writing_ = false; + std::queue> writeQueue_; + std::mutex writeMutex_; + + +public: + ClientStateInterval timedClientStates; + bool joined_ = false; + + bool hasReservedSpawn_ = false; + Eigen::Vector3f reservedSpawn_ = Eigen::Vector3f(0.0f, 0.0f, kWorldZOffset); + + std::string nickname = "Player"; + int shipType = 0; + + Session(Server& server, tcp::socket&& socket, int id); + int get_id() const; + bool hasSpawnReserved() const; + const Eigen::Vector3f& reservedSpawn() const; + bool fetchStateAtTime(std::chrono::system_clock::time_point targetTime, ClientState& outState) const; + void send_message(const std::string& msg); + void run(); + bool IsMessageValid(const std::string& fullMessage); + +private: + void sendBoxesToClient(); +public: + void init(); + ClientState get_latest_state(std::chrono::system_clock::time_point now); + void doWrite(); +private: + + void do_read(); + void process_message(const std::string& msg); +}; + +class Server +{ +public: + tcp::acceptor& acceptor_; + net::io_context& ioc_; + net::steady_timer timer; + std::vector g_boxDestructions; + std::mutex g_boxDestructions_mutex; + + std::vector g_serverBoxes; + std::mutex g_boxes_mutex; + + 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; + + int next_id = 1000; + + std::vector generateServerBoxes(int count); +public: + Server(tcp::acceptor& acceptor, net::io_context& ioc); + + void broadcastToAll(const std::string& message); + void broadcastToAllExceptId(const std::string& message, int id); + void createProjectile(int id, Eigen::Vector3f pos, Eigen::Quaternionf dir, float velocity); + void update_world(); + Eigen::Vector3f PickSafeSpawnPos(int forPlayerId); + void init(); + void accept(); +};