HappyTanuki/Np_Term
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

불안정하게 멀티 됨.. 일단은 두번째 플레이어가 첫번째 플레이어한테 보이기는 하니까...

Browse Source
This commit is contained in:
HappyTanuki
2025-06-15 22:36:04 +09:00
parent 06a1e41dc8
commit 711fc4c93d
11 changed files with 328 additions and 77 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
Server/src/server.cpp
View File

@@ -1,5 +1,6 @@
#include <chrono>
#include "glfw/glfw_initialization.h"
#include "glfw/glfw_monitor.h"
#include "glfw/glfw_window.h"
#include "socket/iocp.h"
#include "socket/packet.h"
#include "socket/tcp_socket.h"
@@ -15,19 +16,37 @@ std::uint8_t CLIENTID = 0;
std::unordered_map<utils::Snowflake, veng::Model> MODELS;
std::mutex MODELS_MUTEX;
std::vector<Network::TCPSocket> CLIENTS;
std::vector<std::pair<Network::TCPSocket, double>> CLIENTS;
std::mutex CLIENTS_MUTEX;
void recv_fully(Network::IOCP* iocp, Network::TCPSocket& sock,
std::vector<char>& buffer) {
size_t total_received = 0;
size_t expected = buffer.size();
while (total_received < expected) {
if (total_received != 0)
Sleep(100); // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
if (sock.sock == 0) return;
std::vector<char> temp(expected - total_received);
size_t received = iocp->recv(sock, temp);
std::copy(temp.begin(), temp.begin() + received,
buffer.begin() + total_received);
total_received += received;
}
}
void EchoClient(utils::ThreadPool* tp, Network::IOCP* iocp,
Network::TCPSocket NewSock, Network::Address NewAddr) {
while (iocp->GetRecvedBytes(NewSock.sock) < 6);
Network::TCPSocket* NewSock, Network::Address NewAddr) {
if (NewSock->sock == 0) return;
std::vector<char> recv_data(6);
iocp->recv(NewSock, recv_data);
recv_fully(iocp, *NewSock, recv_data);
Packet::Header header;
header.Deserialize(recv_data);
recv_data.resize(header.body_length);
while (iocp->GetRecvedBytes(NewSock.sock) < header.body_length);
iocp->recv(NewSock, recv_data);
recv_fully(iocp, *NewSock, recv_data);
switch (header.opcode) {
case Packet::Opcode::UPDATEMODEL: {
@@ -35,24 +54,97 @@ void EchoClient(utils::ThreadPool* tp, Network::IOCP* iocp,
model.Deserialize(recv_data);
std::lock_guard lock(MODELS_MUTEX);
if (MODELS.find(model.ID) == MODELS.end())
spdlog::info("model received: {}", model.ID.snowflake);
MODELS[model.ID] = std::move(model);
}
break;
auto ID = model.ID;
if (MODELS.find(ID) == MODELS.end())
spdlog::info("model received: {}:{}", model.name, ID.snowflake);
MODELS[ID] = std::move(model);
MODELS[ID].needsUpdate = true;
} break;
default:
spdlog::error("unknown data type");
}
// iocp->send(NewSock, recv_data);
tp->enqueueJob(EchoClient, iocp, NewSock, NewAddr);
}
void ClientRefresher(utils::ThreadPool* tp, Network::IOCP* iocp) {
static auto last_all_updated = glfwGetTime();
static auto last_frame_time_ = glfwGetTime();
auto current_time = glfwGetTime();
bool needs_all_update = false;
if (current_time - last_all_updated >= 100) {
needs_all_update = true;
last_all_updated = glfwGetTime();
}
auto delta_time = current_time - last_frame_time_;
last_frame_time_ = current_time;
for (auto it = CLIENTS.begin(); it != CLIENTS.end();) {
if (it->first.sock == 0) {
it = CLIENTS.erase(it);
} else {
++it;
}
}
for (auto it = MODELS.begin(); it != MODELS.end();) {
auto& model = it->second;
if (std::abs(model.lifespan + 1.f) <
std::numeric_limits<float>::epsilon()) {
++it;
continue;
}
if (model.lifespan <= 0.f) {
it = MODELS.erase(it);
continue;
}
if (model.shouldBeDestroyed) {
it = MODELS.erase(it);
continue;
}
model.lifespan -= delta_time;
++it;
}
for (auto& client : CLIENTS) {
if (client.first.sock == 0) continue;
for (auto& model : MODELS) {
if (model.second.name == "camera_lag") continue;
std::vector<char> send_data;
model.second.Update(delta_time + (client.second / 2));
auto model_serialized = model.second.Serialize();
Packet::Header header;
header.opcode = Packet::Opcode::UPDATEMODEL;
header.body_length = model_serialized.size();
auto header_serialized = header.Serialize();
send_data.insert(send_data.end(), header_serialized.begin(),
header_serialized.end());
send_data.insert(send_data.end(), model_serialized.begin(),
model_serialized.end());
if (!model.second.needsUpdate && !needs_all_update) {
continue;
}
model.second.needsUpdate = false;
if (client.first.send(send_data.data(), send_data.size(), 0) == -1) {
client.first.sock = 0;
}
spdlog::info("updated: {}", model.second.name);
}
}
tp->enqueueJob(ClientRefresher, iocp);
}
int main(int argc, char* argv[]) {
Network::WSAManager wsamanager;
const veng::GlfwInitialization _glfw;
#if !defined(NDEBUG)
utils::setDefaultLogger(spdlog::level::level_enum::debug, "log.log", 1024, 2);
utils::setDefaultLogger(spdlog::level::level_enum::debug, "log.log",
1024 * 1024, 2);
#endif
utils::ThreadPool tp(0);
Network::IOCP iocp;
@@ -75,6 +167,8 @@ int main(int argc, char* argv[]) {
std::exit(EXIT_FAILURE);
}
tp.enqueueJob(ClientRefresher, &iocp);
while (true) {
Network::TCPSocket NewSock;
Network::Address NewAddr;
@@ -86,15 +180,22 @@ int main(int argc, char* argv[]) {
Packet::Header header;
header.opcode = Packet::Opcode::CLIENTID;
header.body_length = 8;
header.body_length = 9;
auto packet = header.Serialize();
packet.resize(packet.size() + 8);
packet.resize(packet.size() + 9);
std::lock_guard lock(CLIENTS_MUTEX);
CLIENTS.push_back(NewSock);
std::uint8_t client_id = CLIENTS.size() - 1;
::memcpy(packet.data() + 6, &client_id, 1);
iocp.send(NewSock, packet);
tp.enqueueJob(EchoClient, &iocp, NewSock, NewAddr);
std::double_t timestamp = glfwGetTime();
::memcpy(packet.data() + 7, &timestamp, 8);
iocp.send(NewSock, packet);
std::vector<char> header_buf(6);
recv_fully(&iocp, NewSock, header_buf);
auto ping = glfwGetTime() - timestamp;
CLIENTS.emplace_back(std::move(NewSock), ping);
tp.enqueueJob(EchoClient, &iocp, &CLIENTS.back().first, NewAddr);
}
}