Clean up server
This commit is contained in:
Vladislav Khorev
parent
c35e093cc5
commit
8528b4dc90
@ -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
|
||||
|
||||
@ -1,44 +1,11 @@
|
||||
#include <boost/beast/core.hpp>
|
||||
#include "server.h"
|
||||
#include <boost/beast/websocket.hpp>
|
||||
#include <boost/asio/ip/tcp.hpp>
|
||||
#include <iostream>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <mutex>
|
||||
#include <map>
|
||||
#include <queue>
|
||||
#include <sstream>
|
||||
#include <Eigen/Dense>
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <math.h>
|
||||
#include "../src/network/ClientState.h"
|
||||
#include <random>
|
||||
#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;
|
||||
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<std::string> split(const std::string& s, char delimiter) {
|
||||
std::vector<std::string> tokens;
|
||||
@ -50,279 +17,292 @@ std::vector<std::string> 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<BoxDestroyedInfo> g_boxDestructions;
|
||||
std::mutex g_boxDestructions_mutex;
|
||||
|
||||
std::vector<ServerBox> g_serverBoxes;
|
||||
std::mutex g_boxes_mutex;
|
||||
|
||||
std::vector<std::shared_ptr<class Session>> g_sessions;
|
||||
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> {
|
||||
websocket::stream<beast::tcp_stream> ws_;
|
||||
beast::flat_buffer buffer_;
|
||||
int id_;
|
||||
bool is_writing_ = false;
|
||||
std::queue<std::shared_ptr<std::string>> 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<std::string>(msg);
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(writeMutex_);
|
||||
writeQueue_.push(ss);
|
||||
}
|
||||
doWrite();
|
||||
}
|
||||
|
||||
void run() {
|
||||
{
|
||||
std::lock_guard<std::mutex> lock(g_sessions_mutex);
|
||||
g_sessions.push_back(shared_from_this());
|
||||
}
|
||||
|
||||
ws_.async_accept([self = shared_from_this()](beast::error_code ec) {
|
||||
if (ec) return;
|
||||
std::cout << "Client " << self->id_ << " connected\n";
|
||||
self->init();
|
||||
});
|
||||
}
|
||||
|
||||
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<std::mutex> 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<std::string>(msg);
|
||||
{
|
||||
sendBoxesToClient();
|
||||
|
||||
auto timer = std::make_shared<net::steady_timer>(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<uint64_t>(
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(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<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();
|
||||
});
|
||||
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<std::mutex> lock(g_sessions_mutex);
|
||||
g_sessions.erase(std::remove_if(g_sessions.begin(), g_sessions.end(),
|
||||
[self](const std::shared_ptr<Session>& session) {
|
||||
return session.get() == self.get();
|
||||
}), g_sessions.end());
|
||||
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<std::mutex> 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<std::mutex> 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<net::steady_timer>(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<uint64_t>(
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(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<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();
|
||||
});
|
||||
}
|
||||
|
||||
void Session::do_read() {
|
||||
ws_.async_read(buffer_, [self = shared_from_this()](beast::error_code ec, std::size_t) {
|
||||
if (ec) {
|
||||
std::lock_guard<std::mutex> lock(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>& 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<uint64_t>(
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(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<std::mutex> 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<std::mutex> 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<std::mutex> 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<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(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<std::mutex> 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<std::mutex> lock(g_sessions_mutex);
|
||||
for (auto& session : g_sessions) {
|
||||
if (session->get_id() == this->id_) continue;
|
||||
session->send_message(info);
|
||||
}
|
||||
}
|
||||
{
|
||||
std::lock_guard<std::mutex> 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<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);
|
||||
receivedState.nickname = this->nickname;
|
||||
receivedState.shipType = this->shipType;
|
||||
timedClientStates.add_state(receivedState);
|
||||
|
||||
}
|
||||
else if (type == "RESPAWN") {
|
||||
{
|
||||
std::lock_guard<std::mutex> gd(g_dead_mutex);
|
||||
g_dead_players.erase(id_);
|
||||
}
|
||||
|
||||
{
|
||||
auto now_tp = std::chrono::system_clock::now();
|
||||
uint64_t now_ms = static_cast<uint64_t>(std::chrono::duration_cast<std::chrono::milliseconds>(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<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 - 6.f, 5.0f),
|
||||
Eigen::Vector3f(1.5f, 0.9f - 6.f, 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 = 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<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 Server::broadcastToAllExceptId(const std::string& message, int id)
|
||||
{
|
||||
std::lock_guard<std::mutex> 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<Eigen::Vector3f> 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::milliseconds>((
|
||||
std::chrono::system_clock::now().time_since_epoch())).count();
|
||||
|
||||
std::lock_guard<std::mutex> 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<uint64_t>(
|
||||
std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count());
|
||||
|
||||
// --- Snapshot every 500ms ---
|
||||
/*if (std::chrono::duration_cast<std::chrono::milliseconds>(now - last_snapshot_time).count() >= 500) {
|
||||
last_snapshot_time = now;
|
||||
|
||||
std::string snapshot_msg = "SNAPSHOT:" + std::to_string(now_ms);
|
||||
|
||||
std::lock_guard<std::mutex> 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<std::mutex> 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<ServerBox> generateServerBoxes(int count) {
|
||||
std::vector<ServerBox> Server::generateServerBoxes(int count) {
|
||||
std::vector<ServerBox> boxes;
|
||||
std::random_device rd;
|
||||
std::mt19937 gen(rd());
|
||||
@ -889,34 +754,42 @@ std::vector<ServerBox> 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<std::mutex> 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<Session>(*this, std::move(socket), next_id++)->run();
|
||||
}
|
||||
accept();
|
||||
});
|
||||
}
|
||||
|
||||
int main() {
|
||||
try {
|
||||
{
|
||||
std::lock_guard<std::mutex> 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<Session>(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) {
|
||||
|
||||
137
server/server.h
Normal file
137
server/server.h
Normal file
@ -0,0 +1,137 @@
|
||||
#pragma once
|
||||
#include <boost/beast/core.hpp>
|
||||
#include <boost/beast/websocket.hpp>
|
||||
#include <string>
|
||||
#include <memory>
|
||||
#include <vector>
|
||||
#include <mutex>
|
||||
#include <queue>
|
||||
#include <unordered_set>
|
||||
#include <Eigen/Dense>
|
||||
#include "../src/network/ClientState.h"
|
||||
#define _USE_MATH_DEFINES
|
||||
#include <math.h>
|
||||
|
||||
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<std::string> 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<Session> {
|
||||
Server& server_;
|
||||
websocket::stream<beast::tcp_stream> ws_;
|
||||
beast::flat_buffer buffer_;
|
||||
int id_;
|
||||
bool is_writing_ = false;
|
||||
std::queue<std::shared_ptr<std::string>> 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<BoxDestroyedInfo> g_boxDestructions;
|
||||
std::mutex g_boxDestructions_mutex;
|
||||
|
||||
std::vector<ServerBox> g_serverBoxes;
|
||||
std::mutex g_boxes_mutex;
|
||||
|
||||
std::vector<std::shared_ptr<Session>> g_sessions;
|
||||
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;
|
||||
|
||||
int next_id = 1000;
|
||||
|
||||
std::vector<ServerBox> 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();
|
||||
};
|
||||
Loading…
Reference in New Issue
Block a user