salmon-engine-projects/space-game001
14
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

merge

Browse Source
This commit is contained in:
Vladislav Khorev 2026-02-05 10:43:24 +03:00
commit c49c4626d0
7 changed files with 570 additions and 172 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

448
server/server.cpp
View File

@ -7,14 +7,30 @@
#include <vector> #include <vector>
#include <mutex> #include <mutex>
#include <map> #include <map>
#include <queue>
#include <sstream>
#include <Eigen/Dense> #include <Eigen/Dense>
#define _USE_MATH_DEFINES #define _USE_MATH_DEFINES
#include <math.h> #include <math.h>
#include "../src/network/ClientState.h" #include "../src/network/ClientState.h"
#include <random> #include <random>
#include <algorithm> #include <algorithm>
#include <chrono>
#include <unordered_set>
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<std::string> split(const std::string& s, char delimiter) { std::vector<std::string> split(const std::string& s, char delimiter) {
std::vector<std::string> tokens; std::vector<std::string> tokens;
std::string token; std::string token;
@ -25,127 +41,98 @@ std::vector<std::string> split(const std::string& s, char delimiter) {
return tokens; 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 { struct ServerBox {
Eigen::Vector3f position; Eigen::Vector3f position;
Eigen::Matrix3f rotation; Eigen::Matrix3f rotation;
float collisionRadius = 2.0f; 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<ServerBox> g_serverBoxes; std::vector<ServerBox> g_serverBoxes;
std::mutex g_boxes_mutex; std::mutex g_boxes_mutex;
std::vector<std::shared_ptr<class Session>> g_sessions;
std::vector<std::shared_ptr<Session>> g_sessions;
std::mutex g_sessions_mutex; std::mutex g_sessions_mutex;
std::vector<Projectile> g_projectiles;
std::mutex g_projectiles_mutex;
std::unordered_set<int> g_dead_players;
std::mutex g_dead_mutex;
class Session;
void broadcastToAll(const std::string& message);
class Session : public std::enable_shared_from_this<Session> { class Session : public std::enable_shared_from_this<Session> {
websocket::stream<beast::tcp_stream> ws_; websocket::stream<beast::tcp_stream> ws_;
beast::flat_buffer buffer_; beast::flat_buffer buffer_;
int id_; int id_;
bool is_writing_ = false; bool is_writing_ = false;
std::queue<std::shared_ptr<std::string>> writeQueue_;
std::mutex writeMutex_;
public:
ClientStateInterval timedClientStates; ClientStateInterval timedClientStates;
void process_message(const std::string& msg) { explicit Session(tcp::socket&& socket, int id)
auto now_server = std::chrono::system_clock::now(); : ws_(std::move(socket)), id_(id) {
auto parts = split(msg, ':'); }
if (parts.empty()) { int get_id() const { return id_; }
std::cerr << "Empty message received\n";
return; bool fetchStateAtTime(std::chrono::system_clock::time_point targetTime, ClientState& outState) const {
if (timedClientStates.canFetchClientStateAtTime(targetTime)) {
outState = timedClientStates.fetchClientStateAtTime(targetTime);
return true;
} }
return false;
}
std::string type = parts[0]; void send_message(const std::string& msg) {
auto ss = std::make_shared<std::string>(msg);
if (type == "UPD") { {
if (parts.size() < 16) { std::lock_guard<std::mutex> lock(writeMutex_);
std::cerr << "Invalid UPD message: too few parts (" << parts.size() << ")\n"; writeQueue_.push(ss);
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") { doWrite();
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);
void run() {
{
std::lock_guard<std::mutex> lock(g_sessions_mutex); std::lock_guard<std::mutex> lock(g_sessions_mutex);
std::cout << "Player " << id_ << " fired " << shotCount << " shots → broadcasting\n"; g_sessions.push_back(shared_from_this());
}
for (auto& session : g_sessions) { ws_.async_accept([self = shared_from_this()](beast::error_code ec) {
if (session->get_id() != id_) { if (ec) return;
session->send_message(broadcast); std::cout << "Client " << self->id_ << " connected\n";
} self->init();
} });
}
else {
std::cerr << "Unknown message type: " << type << "\n";
}
} }
void retranslateMessage(const std::string& msg) private:
{ /*
std::string event_msg = "EVENT:" + std::to_string(id_) + ":" + msg; void init() {
sendBoxesToClient();
std::lock_guard<std::mutex> lock(g_sessions_mutex); auto timer = std::make_shared<net::steady_timer>(ws_.get_executor());
for (auto& session : g_sessions) { timer->expires_after(std::chrono::milliseconds(100));
if (session->get_id() != id_) { // Не шлем отправителю timer->async_wait([self = shared_from_this(), timer](const boost::system::error_code& ec) {
session->send_message(event_msg); if (!ec) {
self->send_message("ID:" + std::to_string(self->id_));
self->do_read();
} }
} });
} }
*/
void sendBoxesToClient() { void sendBoxesToClient() {
std::lock_guard<std::mutex> lock(g_boxes_mutex); std::lock_guard<std::mutex> lock(g_boxes_mutex);
@ -162,18 +149,17 @@ class Session : public std::enable_shared_from_this<Session> {
std::to_string(q.z()) + "|"; std::to_string(q.z()) + "|";
} }
if (!boxMsg.empty() && boxMsg.back() == '|') { if (!boxMsg.empty() && boxMsg.back() == '|') boxMsg.pop_back();
boxMsg.pop_back();
}
send_message(boxMsg); send_message(boxMsg);
} }
public: public:
/*
explicit Session(tcp::socket&& socket, int id) explicit Session(tcp::socket&& socket, int id)
: ws_(std::move(socket)), id_(id) { : ws_(std::move(socket)), id_(id) {
} }*/
void init() void init()
{ {
@ -188,7 +174,7 @@ public:
} }
}); });
} }
/*
void run() { void run() {
{ {
@ -203,16 +189,16 @@ public:
// self->send_message("ID:" + std::to_string(self->id_)); // self->send_message("ID:" + std::to_string(self->id_));
// self->do_read(); // self->do_read();
}); });
} }*/
/*void send_message(std::string msg) { /*void send_message(std::string msg) {
auto ss = std::make_shared<std::string>(std::move(msg)); auto ss = std::make_shared<std::string>(std::move(msg));
ws_.async_write(net::buffer(*ss), [ss](beast::error_code, std::size_t) {}); ws_.async_write(net::buffer(*ss), [ss](beast::error_code, std::size_t) {});
}*/ }
int get_id() const { int get_id() const {
return id_; return id_;
} }*/
ClientState get_latest_state(std::chrono::system_clock::time_point now) { ClientState get_latest_state(std::chrono::system_clock::time_point now) {
if (timedClientStates.timedStates.empty()) { if (timedClientStates.timedStates.empty()) {
@ -229,7 +215,7 @@ public:
return latest; return latest;
} }
/*
void send_message(std::string msg) { void send_message(std::string msg) {
auto ss = std::make_shared<std::string>(std::move(msg)); auto ss = std::make_shared<std::string>(std::move(msg));
@ -252,18 +238,42 @@ public:
} }
}); });
} }
} }*/
void doWrite() {
std::lock_guard<std::mutex> 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<std::mutex> lock(self->writeMutex_);
self->writeQueue_.pop();
self->is_writing_ = false;
}
self->doWrite();
});
}
private: private:
void do_read() { void do_read() {
ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) { ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) {
if (ec) if (ec) {
{
std::lock_guard<std::mutex> lock(g_sessions_mutex); std::lock_guard<std::mutex> lock(g_sessions_mutex);
g_sessions.erase(std::remove_if(g_sessions.begin(), g_sessions.end(), g_sessions.erase(std::remove_if(g_sessions.begin(), g_sessions.end(),
[self](const std::shared_ptr<Session>& session) { [self](const std::shared_ptr<Session>& session) {
return session.get() == self.get(); return session.get() == self.get();
}), g_sessions.end()); }), g_sessions.end());
std::cout << "Client " << self->id_ << " disconnected\n";
return; return;
} }
@ -274,9 +284,139 @@ private:
self->do_read(); 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<std::mutex> 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<std::mutex> 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<std::mutex> lock(g_sessions_mutex);
for (auto& session : g_sessions) {
if (session->get_id() != id_) {
session->send_message(broadcast);
}
}
}
{
const std::vector<Eigen::Vector3f> 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::milliseconds>(
std::chrono::system_clock::now().time_since_epoch()).count();
std::lock_guard<std::mutex> 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<std::mutex> 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<std::mutex> 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 update_world(net::steady_timer& timer, net::io_context& ioc) {
static auto last_snapshot_time = std::chrono::steady_clock::now(); static auto last_snapshot_time = std::chrono::steady_clock::now();
auto now = std::chrono::steady_clock::now(); auto now = std::chrono::steady_clock::now();
@ -305,9 +445,105 @@ void update_world(net::steady_timer& timer, net::io_context& ioc) {
} }
}*/ }*/
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) { 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<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count());
std::vector<DeathInfo> deathEvents;
{
std::lock_guard<std::mutex> pl(g_projectiles_mutex);
std::vector<int> 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<uint64_t>(pr.lifeMs)) {
indicesToRemove.push_back(static_cast<int>(i));
continue;
}
bool hitDetected = false;
{
std::lock_guard<std::mutex> lm(g_sessions_mutex);
std::lock_guard<std::mutex> 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<int>(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);
}); });
} }
@ -360,7 +596,6 @@ std::vector<ServerBox> generateServerBoxes(int count) {
return boxes; return boxes;
} }
int main() { int main() {
try { try {
{ {
@ -383,7 +618,6 @@ int main() {
}); });
}; };
net::steady_timer timer(ioc); net::steady_timer timer(ioc);
update_world(timer, ioc); update_world(timer, ioc);

79
src/Game.cpp
View File

@ -1039,11 +1039,16 @@ namespace ZL
if (!uiGameOverShown) { if (!uiGameOverShown) {
if (uiManager.pushMenuFromFile("resources/config/game_over.json", this->renderer, CONST_ZIP_FILE)) { if (uiManager.pushMenuFromFile("resources/config/game_over.json", this->renderer, CONST_ZIP_FILE)) {
uiManager.setButtonCallback("restartButton", [this](const std::string& name) { uiManager.setButtonCallback("restartButton", [this](const std::string& name) {
std::string respawnMsg = "RESPAWN:" + std::to_string(networkClient->GetClientId());
networkClient->Send(respawnMsg);
this->shipAlive = true; this->shipAlive = true;
this->gameOver = false; this->gameOver = false;
this->uiGameOverShown = false; this->uiGameOverShown = false;
this->showExplosion = false; this->showExplosion = false;
this->explosionEmitter.setEmissionPoints(std::vector<Vector3f>()); this->explosionEmitter.setEmissionPoints(std::vector<Vector3f>());
this->deadRemotePlayers.clear();
Environment::shipState.position = Vector3f{ 0, 0, 45000.f }; Environment::shipState.position = Vector3f{ 0, 0, 45000.f };
Environment::shipState.velocity = 0.0f; Environment::shipState.velocity = 0.0f;
@ -1434,6 +1439,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<Vector3f>{ 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<Vector3f>());
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;
}
}
} }
} }

6
src/Game.h
View File

@ -15,6 +15,8 @@
#include <memory> #include <memory>
#include <render/TextRenderer.h> #include <render/TextRenderer.h>
#include <unordered_set>
namespace ZL { namespace ZL {
@ -118,6 +120,7 @@ namespace ZL {
const uint64_t explosionDurationMs = 500; const uint64_t explosionDurationMs = 500;
bool serverBoxesApplied = false; bool serverBoxesApplied = false;
static constexpr float MAX_DIST_SQ = 10000.f * 10000.f; static constexpr float MAX_DIST_SQ = 10000.f * 10000.f;
static constexpr float FADE_START = 6000.f; static constexpr float FADE_START = 6000.f;
static constexpr float FADE_RANGE = 4000.f; static constexpr float FADE_RANGE = 4000.f;
@ -125,6 +128,9 @@ namespace ZL {
static constexpr float PERSPECTIVE_K = 0.05f; // Tune static constexpr float PERSPECTIVE_K = 0.05f; // Tune
static constexpr float MIN_SCALE = 0.4f; static constexpr float MIN_SCALE = 0.4f;
static constexpr float MAX_SCALE = 1.5f; static constexpr float MAX_SCALE = 1.5f;
std::unordered_set<int> deadRemotePlayers;
}; };

13
src/network/LocalClient.h
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
// WebSocketClient.h
#include "NetworkInterface.h" #include "NetworkInterface.h"
#include <queue> #include <queue>
@ -16,8 +15,8 @@ namespace ZL {
void Send(const std::string& message) override; void Send(const std::string& message) override;
bool IsConnected() const override { return true; } bool IsConnected() const override { return true; }
int GetClientId() const { return 1; } int GetClientId() const override { return 1; }
std::vector<ProjectileInfo> getPendingProjectiles(); std::vector<ProjectileInfo> getPendingProjectiles() override;
std::unordered_map<int, ClientStateInterval> getRemotePlayers() override { std::unordered_map<int, ClientStateInterval> getRemotePlayers() override {
return std::unordered_map<int, ClientStateInterval>(); return std::unordered_map<int, ClientStateInterval>();
@ -26,5 +25,13 @@ namespace ZL {
std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> getServerBoxes() override { std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> getServerBoxes() override {
return {}; return {};
} }
std::vector<DeathInfo> getPendingDeaths() override {
return {};
}
std::vector<int> getPendingRespawns() override {
return {};
}
}; };
} }

49
src/network/NetworkInterface.h
View File

@ -7,26 +7,37 @@
// NetworkInterface.h - »нтерфейс дл¤ разных типов соединений // NetworkInterface.h - »нтерфейс дл¤ разных типов соединений
namespace ZL { namespace ZL {
struct ProjectileInfo { struct ProjectileInfo {
int shooterId = -1; int shooterId = -1;
uint64_t clientTime = 0; uint64_t clientTime = 0;
Eigen::Vector3f position = Eigen::Vector3f::Zero(); Eigen::Vector3f position = Eigen::Vector3f::Zero();
//Eigen::Vector3f direction = Eigen::Vector3f::Zero(); //Eigen::Vector3f direction = Eigen::Vector3f::Zero();
Eigen::Matrix3f rotation = Eigen::Matrix3f::Identity(); Eigen::Matrix3f rotation = Eigen::Matrix3f::Identity();
float velocity = 0; float velocity = 0;
}; };
class INetworkClient { struct DeathInfo {
public: int targetId = -1;
virtual ~INetworkClient() = default; uint64_t serverTime = 0;
virtual void Connect(const std::string& host, uint16_t port) = 0; Eigen::Vector3f position = Eigen::Vector3f::Zero();
virtual void Send(const std::string& message) = 0; int killerId = -1;
virtual bool IsConnected() const = 0; };
virtual void Poll() = 0; // ƒл¤ обработки вход¤щих пакетов
virtual std::unordered_map<int, ClientStateInterval> getRemotePlayers() = 0;
virtual std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> 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<int, ClientStateInterval> getRemotePlayers() = 0;
virtual std::vector<ProjectileInfo> getPendingProjectiles() = 0; virtual std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> getServerBoxes() = 0;
};
virtual std::vector<ProjectileInfo> getPendingProjectiles() = 0;
virtual std::vector<DeathInfo> getPendingDeaths() = 0;
virtual std::vector<int> getPendingRespawns() = 0;
virtual int GetClientId() const { return -1; }
};
} }

56
src/network/WebSocketClient.cpp
View File

@ -71,6 +71,20 @@ namespace ZL {
return copy; return copy;
} }
std::vector<DeathInfo> WebSocketClient::getPendingDeaths() {
std::lock_guard<std::mutex> lock(deathsMutex_);
auto copy = pendingDeaths_;
pendingDeaths_.clear();
return copy;
}
std::vector<int> WebSocketClient::getPendingRespawns() {
std::lock_guard<std::mutex> lock(respawnMutex_);
auto copy = pendingRespawns_;
pendingRespawns_.clear();
return copy;
}
void WebSocketClient::Poll() { void WebSocketClient::Poll() {
std::lock_guard<std::mutex> lock(queueMutex); std::lock_guard<std::mutex> lock(queueMutex);
@ -125,6 +139,25 @@ namespace ZL {
} }
continue; 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<std::mutex> rLock(respawnMutex_);
pendingRespawns_.push_back(respawnedPlayerId);
}
{
std::lock_guard<std::mutex> pLock(playersMutex);
remotePlayers.erase(respawnedPlayerId);
}
std::cout << "Client: Received RESPAWN_ACK for player " << respawnedPlayerId << std::endl;
}
catch (...) {}
}
continue;
}
if (msg.rfind("PROJECTILE:", 0) == 0) { if (msg.rfind("PROJECTILE:", 0) == 0) {
auto parts = split(msg, ':'); auto parts = split(msg, ':');
@ -150,8 +183,29 @@ namespace ZL {
std::lock_guard<std::mutex> pl(projMutex_); std::lock_guard<std::mutex> pl(projMutex_);
pendingProjectiles_.push_back(pi); 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<std::mutex> dl(deathsMutex_);
pendingDeaths_.push_back(di);
} }
catch (...) {}
} }
continue; continue;
} }

91
src/network/WebSocketClient.h
View File

@ -2,7 +2,6 @@
#ifdef NETWORK #ifdef NETWORK
// WebSocketClient.h
#include "NetworkInterface.h" #include "NetworkInterface.h"
#include <queue> #include <queue>
#include <boost/beast/core.hpp> #include <boost/beast/core.hpp>
@ -12,62 +11,70 @@
namespace ZL { namespace ZL {
class WebSocketClient : public INetworkClient { class WebSocketClient : public INetworkClient {
private: private:
// Переиспользуем io_context из TaskManager // Переиспользуем io_context из TaskManager
boost::asio::io_context& ioc_; boost::asio::io_context& ioc_;
// Объекты переехали в члены класса // Объекты переехали в члены класса
std::unique_ptr<boost::beast::websocket::stream<boost::beast::tcp_stream>> ws_; std::unique_ptr<boost::beast::websocket::stream<boost::beast::tcp_stream>> ws_;
boost::beast::flat_buffer buffer_; boost::beast::flat_buffer buffer_;
std::queue<std::string> messageQueue; std::queue<std::string> messageQueue;
std::mutex queueMutex; // Защита для messageQueue std::mutex queueMutex; // Защита для messageQueue
std::queue<std::shared_ptr<std::string>> writeQueue_; std::queue<std::shared_ptr<std::string>> writeQueue_;
bool isWriting_ = false; bool isWriting_ = false;
std::mutex writeMutex_; // Отдельный мьютекс для очереди записи std::mutex writeMutex_; // Отдельный мьютекс для очереди записи
bool connected = false; bool connected = false;
int clientId = -1; int clientId = -1;
std::unordered_map<int, ClientStateInterval> remotePlayers; std::unordered_map<int, ClientStateInterval> remotePlayers;
std::mutex playersMutex; std::mutex playersMutex;
// Серверные коробки // Серверные коробки
std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> serverBoxes_; std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> serverBoxes_;
std::mutex boxesMutex; std::mutex boxesMutex;
std::vector<ProjectileInfo> pendingProjectiles_; std::vector<ProjectileInfo> pendingProjectiles_;
std::mutex projMutex_; std::mutex projMutex_;
void startAsyncRead(); std::vector<DeathInfo> pendingDeaths_;
void processIncomingMessage(const std::string& msg); std::mutex deathsMutex_;
public: std::vector<int> pendingRespawns_;
explicit WebSocketClient(boost::asio::io_context& ioc) : ioc_(ioc) {} 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 Connect(const std::string& host, uint16_t port) override;
void doWrite();
bool IsConnected() const override { return connected; } void Poll() override;
int GetClientId() const { return clientId; }
std::unordered_map<int, ClientStateInterval> getRemotePlayers() override { void Send(const std::string& message) override;
std::lock_guard<std::mutex> lock(playersMutex); void doWrite();
return remotePlayers;
}
std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> getServerBoxes() override { bool IsConnected() const override { return connected; }
std::lock_guard<std::mutex> lock(boxesMutex); int GetClientId() const override { return clientId; }
return serverBoxes_;
}
std::vector<ProjectileInfo> getPendingProjectiles() override; std::unordered_map<int, ClientStateInterval> getRemotePlayers() override {
}; std::lock_guard<std::mutex> lock(playersMutex);
return remotePlayers;
}
std::vector<std::pair<Eigen::Vector3f, Eigen::Matrix3f>> getServerBoxes() override {
std::lock_guard<std::mutex> lock(boxesMutex);
return serverBoxes_;
}
std::vector<ProjectileInfo> getPendingProjectiles() override;
std::vector<DeathInfo> getPendingDeaths() override;
std::vector<int> getPendingRespawns() override;
};
} }
#endif #endif