SQCSimulator2023/SQCSim-srv/connection.cpp

202 lines
4.8 KiB
C++
Raw Normal View History

2023-09-24 08:45:40 -04:00
#include "connection.h"
2023-12-06 12:17:47 -05:00
Connection::Connection(SOCKET sock,
sockaddr_in sockaddr,
LoginInfo log,
PlayerInfo play) :
m_sock(sock),
m_addr(sockaddr),
m_loginfo(log),
m_playinfo(play) {
2023-09-24 08:45:40 -04:00
}
2023-10-25 12:16:14 -04:00
Connection::~Connection() { closesocket(m_sock); }
2023-09-24 08:45:40 -04:00
2023-12-06 12:17:47 -05:00
uint64_t Connection::GetHash(bool self) const { return self ? m_loginfo.sid : m_playinfo.id; }
2023-09-24 08:45:40 -04:00
uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; }
2023-09-24 08:45:40 -04:00
std::string Connection::GetName() const { return m_loginfo.name; }
2023-09-24 08:45:40 -04:00
2023-12-05 13:44:54 -05:00
void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); m_input_vector.push_back(in); }
2023-09-24 11:07:03 -04:00
2023-10-25 12:16:14 -04:00
Output* Connection::getOutput(Timestamp time) {
2023-09-24 11:07:03 -04:00
auto out = m_output_manifest.find(time);
if (out != m_output_manifest.end())
return &out->second;
return nullptr;
}
2023-10-25 12:16:14 -04:00
Sync Connection::getSync(Timestamp time) {
Sync sync;
2023-09-24 11:07:03 -04:00
auto out = m_output_manifest.find(time);
if (out != m_output_manifest.end()) {
sync.timestamp = out->second.timestamp;
sync.position = out->second.position;
sync.sid = m_loginfo.sid;
2023-09-24 11:07:03 -04:00
}
return sync;
}
2023-10-25 12:16:14 -04:00
SOCKET Connection::getSock() const { return m_sock; }
PlayerInfo* Connection::getInfo() const { return (PlayerInfo*)&m_playinfo; }
2023-10-26 17:57:42 -04:00
sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
2023-11-06 17:59:57 -05:00
void Connection::getPacks(SOCKET sock) {
std::vector<char*> lsPck;
Input in;
2023-12-05 13:44:54 -05:00
Sync sync;
2023-12-06 12:17:47 -05:00
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)) {
m_input_manifest[in.timestamp] = in;
m_input_vector.push_back(in);
}
2023-12-06 12:17:47 -05:00
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize))
m_nsync = true;
break;
default: break;
}
2023-12-06 12:17:47 -05:00
}
lsPck.clear();
}
2023-12-05 13:44:54 -05:00
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();
2023-11-06 17:59:57 -05:00
for (auto& [key, conn] : conns) {
2023-12-05 13:44:54 -05:00
if (m_playinfo.id == conn->GetHash(false))
2023-11-06 17:59:57 -05:00
continue;
2023-12-05 13:44:54 -05:00
//std::cout << m_playinfo.id << ": " << m_playinfo.name << ": " << conn->GetName() << std::endl;
//std::cout << out.id << ": " << out.position << std::endl;
2023-11-06 17:59:57 -05:00
sendPackTo<Output>(sock, &out, &m_bufout, conn->getAddr());
}
2023-11-27 16:12:12 -05:00
++outs;
[[unlikely]] if (last == 0) // !
last = out.timestamp;
outs += out.timestamp + last;
if (outs >= 1000) {
outs -= 1000;
Sync sync;
2023-12-05 06:25:48 -05:00
sync.hp = player->GetHP();
2023-11-27 16:12:12 -05:00
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);
}
2023-11-24 15:56:58 -05:00
m_output_vector.pop_front();
2023-11-06 17:59:57 -05:00
}
}
2023-12-05 06:25:48 -05:00
Timestamp Connection::Run(World* world) {
Input in, last;
Output out;
2023-12-05 06:25:48 -05:00
Timestamp tstamp = 0;
float el;
if (m_input_manifest.size() < 2)
2023-12-05 06:25:48 -05:00
return tstamp;
2023-12-06 13:23:33 -05:00
if (player->AmIDead()) {
m_input_manifest.clear();
return tstamp;
}
2023-12-05 13:44:54 -05:00
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;
}
2023-12-02 11:05:00 -05:00
2023-12-05 06:25:48 -05:00
player->SetDirection(in.direction);
2023-12-06 12:17:47 -05:00
player->ApplyPhysics(player->GetInput(in.keys.forward,
in.keys.backward,
in.keys.left,
in.keys.right,
in.keys.jump, false, el), world, el);
2023-12-06 11:16:39 -05:00
if (player->GetPosition().y < -10.) {
player->InflictDamage(9000);
player->Killer = GetHash(true);
}
2023-12-05 14:25:21 -05:00
out.states.jumping = in.keys.jump;
out.states.running = player->GetVelocity().Length() > .3f;
2023-12-06 12:17:47 -05:00
2023-12-06 11:16:39 -05:00
if (player->AmIDead()) {
in.keys.shoot = false;
in.keys.block = false;
out.states.dead = true;
}
2023-12-05 06:25:48 -05:00
2023-12-06 12:17:47 -05:00
static bool toggle = false;
2023-12-05 06:25:48 -05:00
if (in.keys.block) {
2023-12-06 12:17:47 -05:00
if (!toggle) {
toggle = true;
bool block = false;
ChunkMod* cmod = world->ChangeBlockAtCursor(BLOCK_TYPE::BTYPE_METAL,
player->GetPosition(),
player->GetDirection(),
block, true);
if (cmod)
ChunkDiffs.emplace_back(cmod);
}
2023-12-05 06:25:48 -05:00
}
2023-12-06 12:17:47 -05:00
else toggle = false;
2023-12-02 11:05:00 -05:00
2023-12-05 14:25:21 -05:00
if (in.keys.shoot && m_shoot_acc <= 0.) {
2023-12-06 11:16:39 -05:00
Bullets.emplace_back(new Bullet(player->GetPOV() + player->GetDirection(), player->GetDirection(), GetHash(true)));
2023-12-05 14:25:21 -05:00
out.states.shooting = true;
2023-12-06 12:17:47 -05:00
m_shoot_acc = BULLET_TIME;
2023-12-05 14:25:21 -05:00
}
2023-12-06 12:17:47 -05:00
2023-12-05 06:25:48 -05:00
out.position = player->GetPositionAbs();
2023-11-06 17:59:57 -05:00
out.direction = in.direction;
out.timestamp = in.timestamp;
out.id = m_playinfo.id;
m_output_manifest[out.timestamp] = out;
2023-11-24 14:15:40 -05:00
m_output_vector.push_back(out);
2023-12-05 06:25:48 -05:00
tstamp = out.timestamp;
2023-12-06 12:17:47 -05:00
2023-11-06 17:59:57 -05:00
++m_last_in;
}
2023-12-05 06:25:48 -05:00
return tstamp;
}
2023-09-24 11:07:03 -04:00
void Connection::CleanInputManifest(Timestamp time) {
2023-12-06 12:17:47 -05:00
// auto wat = m_input_manifest.find(time);
2023-09-24 11:07:03 -04:00
2023-12-06 12:17:47 -05:00
// while (wat != m_input_manifest.begin())
// m_input_manifest.erase(wat--);
2023-09-24 08:45:40 -04:00
}
2023-12-05 06:25:48 -05:00
Timestamp Connection::GetTStamp() const { return m_tstamp; }