memartel/SQCSimulator2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Revert "IGNORE THIS"

Browse Source
This commit is contained in:
MarcEricMartel
2023-12-04 13:14:54 -05:00
committed by GitHub
parent c5700ae9fd
commit 8569e17c93
69 changed files with 223 additions and 542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

84
SQCSim-srv/connection.cpp
View File

@@ -21,7 +21,7 @@ uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
std::string Connection::GetName() const { return m_loginfo.name; }
void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); m_input_vector.push_back(in); }
void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); }
Output* Connection::getOutput(Timestamp time) {
auto out = m_output_manifest.find(time);
@@ -50,62 +50,33 @@ sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
void Connection::getPacks(SOCKET sock) {
std::vector<char*> lsPck;
Input in;
Sync sync;
while (true) {
lsPck = recvPacksFrom(sock, &m_buf, m_addr);
for (auto& pck : lsPck) {
uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
switch (netprot::getType(pck, 1)) {
using enum netprot::PACKET_TYPE;
case INPUT:
if (Deserialize(&in, pck, &bsize)) {
if (Deserialize(&in, pck, &bsize))
m_input_manifest[in.timestamp] = in;
m_input_vector.push_back(in);
}
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize))
m_nsync = true;
break;
default: break;
}
}
lsPck.clear();
}
}
void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer) {
static int outs = 0;
static Timestamp last = 0;
while (!m_output_vector.empty()) {
Output out = m_output_vector.front();
for (auto& [key, conn] : conns) {
if (m_playinfo.id == conn->GetHash(false))
continue;
//std::cout << m_playinfo.id << ": " << m_playinfo.name << ": " << conn->GetName() << std::endl;
//std::cout << out.id << ": " << out.position << std::endl;
void Connection::sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns) {
while (m_last_out < m_output_manifest.size()) {
Output out = m_output_manifest.at(m_last_out++);
for (auto& [key, conn] : conns) {
if (m_playinfo.id == conn->GetHash(true))
continue;
sendPackTo<Output>(sock, &out, &m_bufout, conn->getAddr());
}
++outs;
[[unlikely]] if (last == 0) // !
last = out.timestamp;
outs += out.timestamp + last;
if (outs >= 1000) {
outs -= 1000;
Sync sync;
sync.hp = player.get()->GetHP();
sync.timestamp = out.timestamp;
sync.position = out.position;
sync.sid = m_loginfo.sid;
sync.timer = timer;
sync.timestamp = out.timestamp;
sync.ammo = -1;
sendPackTo<Sync>(sock, &sync, &m_bufout, &m_addr);
}
m_output_vector.pop_front();
}
}
@@ -117,18 +88,11 @@ void Connection::Run(World* world) {
if (m_input_manifest.size() < 2)
return;
while (m_last_in < m_input_vector.size() - 1) {
in = m_input_vector.at(m_last_in + 1);
last = m_input_vector.at(m_last_in);
el = (double)(in.timestamp - last.timestamp) / 1000.;
if (m_shoot_acc > 0.) {
m_shoot_acc -= el;
if (m_shoot_acc < 0.)
m_shoot_acc = 0;
}
while (m_last_in < m_input_manifest.size()) {
in = m_input_manifest.at(m_last_in + 1);
last = m_input_manifest.at(m_last_in);
el = (float)(in.timestamp - last.timestamp) / 1000.;
player.get()->SetDirection(in.direction);
player.get()->ApplyPhysics(player.get()->GetInput(in.keys.forward,
in.keys.backward,
@@ -136,28 +100,20 @@ void Connection::Run(World* world) {
in.keys.right,
in.keys.jump, false, el), world, el);
//if (in.keys.block)
// ChunkDiffs.push_back()
if (in.keys.shoot && m_shoot_acc <= 0.)
Bullets.push_back(Bullet(player.get()->GetPOV() + player.get()->GetDirection(), player.get()->GetDirection()));
out.position = player.get()->GetPositionAbs();
out.position = player.get()->GetPosition();
out.direction = in.direction;
out.timestamp = in.timestamp;
out.id = m_playinfo.id;
m_output_manifest[out.timestamp] = out;
m_output_vector.push_back(out);
++m_last_in;
}
}
void Connection::CleanInputManifest(Timestamp time) {
// auto wat = m_input_manifest.find(time);
auto wat = m_input_manifest.find(time);
// while (wat != m_input_manifest.begin())
// m_input_manifest.erase(wat--);
while (wat != m_input_manifest.begin())
m_input_manifest.erase(wat--);
}

12
SQCSim-srv/connection.h
View File

@@ -34,26 +34,16 @@ public:
sockaddr_in* getAddr() const;
void getPacks(SOCKET sock);
void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer);
void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns);
void Run(World* world);
void CleanInputManifest(Timestamp time);
bool m_nsync = true;
std::vector<Bullet> Bullets;
std::vector<ChunkMod> ChunkDiffs;
private:
std::unordered_map<Timestamp, Input> m_input_manifest;
std::vector<Input> m_input_vector;
std::unordered_map<Timestamp, Output> m_output_manifest;
std::deque<Output> m_output_vector;
std::unordered_map<Timestamp, Chat> m_chatlog;
float m_shoot_acc = 0;
SOCKET m_sock;
sockaddr_in m_addr;
LoginInfo m_loginfo;

186
SQCSim-srv/server.cpp
View File

@@ -17,11 +17,10 @@ Server::~Server() {
if (m_sock_udp)
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
closesocket(m_sock_tcp);
for (const auto& [key, player] : m_players)
closesocket(player->getSock());
m_players.clear();
delete m_world;
closesocket(player->getSock());
m_players.clear();
#ifdef _WIN32
WSACleanup();
#endif
@@ -69,16 +68,15 @@ int Server::Init() {
}
int Server::Ready() {
int nbrjoueurs = 0,
int nbrjoueurs = 0,
nbrconn = 0;
bool readystart = false;
do {
Log("Entrez la duree de la partie: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
try {
m_game.countdown = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
} catch(const std::exception& e) {
Log(e.what(), true, false);
m_game.countdown = 0;
}
@@ -86,10 +84,9 @@ int Server::Ready() {
do {
Log("Entrez le seed de la partie: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
m_game.seed = 9370707;//std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
try {
m_game.seed = std::stoi(m_buf.ptr);
} catch(const std::exception& e) {
Log(e.what(), true, false);
m_game.seed = 0;
}
@@ -97,10 +94,9 @@ int Server::Ready() {
do {
Log("Entrez le nombre de joueurs: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
try {
nbrjoueurs = std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
} catch(const std::exception& e) {
Log(e.what(), true, false);
nbrjoueurs = 0;
}
@@ -116,9 +112,9 @@ int Server::Ready() {
}
buildIdList(ID_LIST_SIZE);
Log("A l'ecoute sur le port: " + std::to_string(SRV_PORT), false, false);
while (!readystart) {
sockaddr_in sockad;
addrlen_t addrlen = sizeof(sockad);
@@ -138,7 +134,7 @@ int Server::Ready() {
if (pck.type != PACKET_TYPE::LOGINF) {
Log("Paquet invalide.", true, false);
if (pck.type != PACKET_TYPE::ERR)
netprot::emptyPack(pck);
netprot::emptyPack(pck);
continue; // Passer au prochain appel si c'est pas un LoginInfo ou un LoginInfo invalide qui rentre.
}
LoginInfo* log = (LoginInfo*)pck.ptr;
@@ -148,24 +144,25 @@ int Server::Ready() {
Log(str.append(" Nom: ").append(log->name), false, false);
str.clear();
Log(str.append(log->name).append(" SID: [").append(std::to_string(log->sid).append("]")), false, false);
sendPackTo<LoginInfo>(m_sock_udp, log, &m_buf, &sockad);
sendPack<LoginInfo>(sock, log, &m_buf);
play.id = getUniqueId();
play.tid = log->tid;
strcpy(play.name, log->name);
Log(str.append(play.name).append(" SID: [").append(std::to_string(log->sid)).append("]")
.append(" ID: [").append(std::to_string(play.id)).append("]")
.append(" TID: [").append(std::to_string(play.tid)).append("]"), false, false);
play.tid = log->tid;
sendPackTo<GameInfo>(m_sock_udp, &m_game, &m_buf, &sockad);
std::cout << m_game.seed << std::endl;
sendPack<GameInfo>(sock, &m_game, &m_buf);
Connection* conn = new Connection(sock, sockad, *log, play);
m_players[log->sid] = conn;
for (auto& [key, player] : m_players) {
sendPack<PlayerInfo>(player->getSock(), &play, &m_buf); // Envoyer les infos de joueur distant aux joueurs d<>j<EFBFBD> connect<63>s
sendPack<PlayerInfo>(sock, player->getInfo(), &m_buf); // et envoyer les infos des joueurs distants au nouveau joueur.
}
m_players[log->sid] = std::move(conn);
delete log;
@@ -174,13 +171,6 @@ int Server::Ready() {
}
}
}
for (auto& [keyin, playin] : m_players) // Not pretty, but it works.
for (auto& [keyout, playout] : m_players) {
if (keyin == keyout)
continue;
sendPackTo<PlayerInfo>(m_sock_udp, playout->getInfo(), &m_buf, playin->getAddr()); // et envoyer les infos des joueurs distants au nouveau joueur.
}
return 0;
}
@@ -189,7 +179,7 @@ void Server::Run() {
Input in;
sockaddr_in sockad;
addrlen_t socklen = sizeof(sockad);
Log("Debut de la partie...", false, false);
int players = m_players.size();
@@ -198,92 +188,53 @@ void Server::Run() {
m_world->SetSeed(m_game.seed);
m_world->GetChunks().Reset(nullptr);
m_world->BuildWorld();
for (auto& [key, conn] : m_players) { // Creation des instances de joueurs et premier sync.
int x = (rand() % (CHUNK_SIZE_X * WORLD_SIZE_X - 1)) - (CHUNK_SIZE_X * WORLD_SIZE_X / 2),
y = (rand() % (CHUNK_SIZE_Y * WORLD_SIZE_Y - 1)) - (CHUNK_SIZE_Y * WORLD_SIZE_Y / 2);
conn->player = std::make_unique<Player>(Vector3f(x + .5f, CHUNK_SIZE_Y + 1.8f, y + .5f));
conn->player = std::make_unique<Player>(Vector3f(8.5f, CHUNK_SIZE_Y + 1.8f, 8.5f));
Sync sync;
sync.position = conn->player->GetPositionAbs();
sync.position = conn->player->GetPosition();
sync.hp = conn->player->GetHP();
sync.sid = key;
sync.ammo = 0;
sync.timestamp = 0;
sync.timer = m_game.countdown;
sendPackTo<Sync>(m_sock_udp, &sync, &m_buf, conn->getAddr());
sendPack<Sync>(conn->getSock(), &sync, &m_buf);
}
int timer = m_game.countdown, sync_acc = 0;
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
Timestamp last = 0;
std::vector<Chat> chatlog;
while (!endgame) {
using namespace std::chrono;
Timestamp tstamp = duration_cast<milliseconds>(high_resolution_clock::now() - start).count();
if (last == 0)
last = tstamp;
sync_acc += tstamp - last;
if (sync_acc >= 1000) {
sync_acc -= 1000;
--timer;
}
for (auto& [key, conn] : m_players) {
/* In */
int deadplayers = 0;
std::vector<char*> lsPck;
Input in; Chat chat; Sync sync;
lsPck = recvPacks(m_sock_udp, &m_buf);
for (auto& pck : lsPck) {
uint32_t bsize = m_buf.len - (pck - m_buf.ptr);
switch (netprot::getType(pck, 1)) {
using enum netprot::PACKET_TYPE;
case INPUT:
if (Deserialize(&in, pck, &bsize))
m_players[in.sid]->AddInput(in);
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize)) {}
break;
case CHAT:
if (Deserialize(&chat, pck, &bsize))
chatlog.push_back(chat);
break;
default: break;
}
}
lsPck.clear();
/* Process */
if (conn->m_nsync) {
if (conn->player->AmIDead()) {
++deadplayers;
conn->m_nsync == false;
continue;
}
conn->Run(m_world);
/* Out */
conn->sendPacks(m_sock_udp, m_players, timer);
}
if (deadplayers == players - 1 || timer <= 0)
endgame = true;
conn->getPacks(m_sock_udp);
conn->Run(m_world);
conn->sendPacks(m_sock_udp, m_players);
}
for (auto& chat : chatlog)
for (auto& [key, conn] : m_players)
sendPackTo<Chat>(m_sock_udp, &chat, &m_buf, conn->getAddr());
chatlog.clear();
}
// TODO: Gérer les 2-3 secondes post-game avant le billboard pour pas avoir un whiplash à la fin de la game.
//while (true) {
// if (recvfrom(m_sock_udp, m_buf.ptr, m_buf.len, 0, (sockaddr*)&sockad, &socklen) > 0) {
// Packet pck = getPack(&m_buf);
// switch (pck.type) {
// using enum netprot::PACKET_TYPE;
// case ERR: std::puts("ERROR!"); break;
// case INPUT: std::puts("INPUT!"); break;
// case OUTPUT: std::puts("OUTPUT!"); break;
// case SYNC: std::puts("SYNC!"); break;
// case TEAMINF: std::puts("TEAMINF!"); break;
// case SELFINF: std::puts("SELFINF!"); break;
// case PLAYINF: std::puts("PLAYINF!"); break;
// case LOGINF: std::puts("LOGINF!"); break;
// case CHUNKMOD: std::puts("CHUNKMOD!"); break;
// case PLAYERMOD: std::puts("PLAYERMOD!"); break;
// case PICKUPMOD: std::puts("PICKUPMOD!"); break;
// case GAMEINFO: std::puts("GAMEINFO!"); break;
// case ENDINFO: std::puts("ENDINFO!"); break;
// case CHAT: std::puts("CHAT!"); break;
// case ERRLOG: std::puts("ERRLOG!"); break;
// case LAST_PACK: [[falltrough]];
// default: std::puts("wtf?!"); break;
// }
// netprot::emptyPack(pck);
// }
//}
}
@@ -309,13 +260,13 @@ inline std::string Server::LogTimestamp() {
void Server::Log(std::string str, bool is_error = false, bool is_fatal = false) {
switch (m_log) {
using enum LOG_DEST; // C++20!
case LOGFILE:
m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
case CONSOLE: [[fallthrough]]; // Pour dire que c'est voulu que ça traverse vers le case en dessous (C++17!)
default:
std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
case LOGFILE:
m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
case CONSOLE: [[fallthrough]]; // Pour dire que c'est voulu que ça traverse vers le case en dessous (C++17!)
default:
std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl;
break;
}
if (is_fatal) {
@@ -328,7 +279,6 @@ void Server::Log(std::string str, bool is_error = false, bool is_fatal = false)
for (const auto& [key, player] : m_players) {
closesocket(player->getSock());
}
delete m_world;
m_players.clear();
#ifdef _WIN32
WSACleanup();
@@ -343,7 +293,7 @@ void Server::buildIdList(size_t size) {
srand(time(NULL));
do lst.insert(((uint64_t)rand() << 32 | rand()));
while (lst.size() < size);
m_ids = std::vector<uint64_t>(lst.begin(), lst.end());
}