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

Merge pull request #39 from CegepSTH/PauseMenuFieldsAndOnline

Browse Source 
Beaucoup de belles choses
This commit is contained in:
Jonathan Trottier 2023-12-12 19:28:28 -05:00 committed by GitHub
commit 6c68114fbb
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
34 changed files with 1938 additions and 589 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
SQCSim-common/SQCSim-common.vcxproj
View File

@ -48,7 +48,7 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>StaticLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<PlatformToolset>ClangCL</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>

33
SQCSim-common/bullet.cpp
View File

@ -3,19 +3,32 @@
Bullet::Bullet(Vector3f pos, Vector3f dir) : m_startpos(pos), m_currentpos(pos), m_velocity(dir) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t tid): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_tid(tid) {}
Bullet::Bullet(Vector3f pos, Vector3f dir, uint64_t shooter_id): m_startpos(pos), m_currentpos(pos), m_velocity(dir), m_shooter_id(shooter_id) {}
Bullet::~Bullet() {}
bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> mapPlayer) {
bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> mapPlayer, netprot::ChunkMod** chunkmod) {
int max = 100 / perframe;
float damage = 0.057f;
for (int x = 0; x < max; ++x) {
m_currentpos += m_velocity * elapsedtime;
for (auto& [key, player] : mapPlayer) {
if ((m_currentpos - player->GetPosition()).Length() < .4f) {
bool hit = false;
if ((m_currentpos - player->GetPosition()).Length() < .6f) {
hit = true;
}
if ((m_currentpos - player->GetPOV()).Length() < .2f) {
damage *= 2; // HEADSHOT!
hit = true;
}
if (hit && !player->AmIDead()) {
player->InflictDamage(damage);
player->m_hit = true;
if (player->AmIDead())
player->Killer = m_shooter_id;
return true;
}
}
@ -23,6 +36,14 @@ bool Bullet::Update(World* world, float elapsedtime, int perframe, std::unordere
if (!world->ChunkAt(m_currentpos))
return true;
else if (world->BlockAt(m_currentpos) != BTYPE_AIR) {
if (chunkmod) {
using namespace netprot;
*chunkmod = new ChunkMod();
(*chunkmod)->old_b_type = world->BlockAt(m_currentpos);
(*chunkmod)->b_type = BTYPE_AIR;
(*chunkmod)->pos = m_currentpos;
}
world->ChangeBlockAtPosition(BTYPE_AIR, m_currentpos);
return true;
}
@ -47,6 +68,6 @@ Vector3f Bullet::getVel() const {
return m_velocity;
}
uint64_t Bullet::getTeamID(){
return m_tid;
}
//uint64_t Bullet::getTeamID(){
// return m_tid;
//}

8
SQCSim-common/bullet.h
View File

@ -5,7 +5,7 @@
#include "define.h"
#include "vector3.h"
#include "player.h"
#include "netprotocol.h"
class World;
class Player;
@ -16,17 +16,17 @@ public:
Bullet(Vector3f pos, Vector3f dir, uint64_t tid);
~Bullet();
bool Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> m_mapPlayer);
bool Update(World* world, float elapsedtime, int perframe, std::unordered_map<uint64_t, Player*> m_mapPlayer, netprot::ChunkMod** chunkmod);
void Transpose(int& x, int& z);
Vector3f getPos() const;
Vector3f getVel() const;
uint64_t getTeamID();
//uint64_t getTeamID();
private:
Vector3f m_startpos,
m_currentpos,
m_velocity;
uint64_t m_tid = 0;
uint64_t m_shooter_id = 0;
};

4
SQCSim-common/define.h
View File

@ -41,8 +41,11 @@ typedef uint8_t BlockType;
enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_GREENGRASS, BTYPE_LAST };
typedef uint8_t BoostType;
enum BOOST_TYPE { BTYPE_SPEED, BTYPE_HEAL, BTYPE_DAMAGE, BTYPE_INVINCIBLE, BTYPE_BOOST_LAST };
//anim
enum ANIM_TYPE { STILL = 0, SHOOTING = 8, JUMPING = 16, JUMPINGSHOOTING = 24, DEAD = 32, TYPE_LAST = 40};
enum ANIM_POS {FRONT, QUARTER_FRONT_LEFT, QUATER_FRONT_RIGHT, PROFIL_LEFT, PROFIL_RIGHT, QUARTER_BACK_LEFT, QUARTER_BACK_RIGHT, BACK , POS_LAST};
typedef uint64_t Timestamp;
#ifdef _WIN32
@ -74,6 +77,7 @@ typedef uint64_t Timestamp;
#include <arpa/inet.h>
#include <netinet/in.h>
#include <cstring>
#include <poll.h>
#define flag_t unsigned int
#define addrlen_t unsigned int

382
SQCSim-common/netprotocol.cpp
View File

@ -29,13 +29,13 @@ void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) {
Keys keys = in->keys;
uint8_t keys8 = // Reste un bit.
keys.forward & 0b10000000 |
keys.backward & 0b01000000 |
keys.left & 0b00100000 |
keys.right & 0b00010000 |
keys.jump & 0b00001000 |
keys.shoot & 0b00000100 |
keys.block & 0b00000010;
(keys.forward ? 0b10000000 : 0) |
(keys.backward ? 0b01000000 : 0) |
(keys.left ? 0b00100000 : 0) |
(keys.right ? 0b00010000 : 0) |
(keys.jump ? 0b00001000 : 0) |
(keys.shoot ? 0b00000100 : 0) |
(keys.block ? 0b00000010 : 0);
memcpy(*buf + sizeof(uint64_t) * 2 + 1, &keys8, sizeof(uint8_t));
@ -90,14 +90,14 @@ void netprot::Serialize(Output* out, char* buf[], uint32_t* buflen) {
States states = out->states;
uint8_t states8 =
states.jumping & 0b10000000 |
states.shooting & 0b01000000 |
states.hit & 0b00100000 |
states.powerup & 0b00010000 |
states.dead & 0b00001000 |
states.still & 0b00000100 |
states.jumpshot & 0b00000010 |
states.running & 0b00000001;
(states.jumping ? 0b10000000 : 0) |
(states.shooting ? 0b01000000 : 0) |
(states.hit ? 0b00100000 : 0) |
(states.powerup ? 0b00010000 : 0) |
(states.dead ? 0b00001000 : 0) |
(states.still ? 0b00000100 : 0) |
(states.jumpshot ? 0b00000010 : 0) |
(states.running ? 0b00000001 : 0);
memcpy(*buf + sizeof(uint64_t) * 2 + 1, &states8, sizeof(uint8_t));
@ -181,8 +181,6 @@ void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) {
memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) + 1, ammo8, sizeof(uint16_t));
memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t) + 1, &sync->hp, sizeof(uint8_t));
uint32_t vec[3];
memcpy(vec, &sync->position, sizeof(Vector3f)); // Pour d<>naturer les floats.
@ -200,9 +198,21 @@ void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) {
(uint8_t)((vec[2] >> 8) & 0xFF),
(uint8_t)(vec[2] & 0xFF) };
memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t) + 2, vec8, sizeof(uint32_t) * 3);
memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t) + 1, vec8, sizeof(uint32_t) * 3);
*buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + 2;
uint32_t hp;
memcpy(&hp, &sync->hp, sizeof(float));
uint8_t hp8[4] = {
(uint8_t)((hp >> 24) & 0xFF),
(uint8_t)((hp >> 16) & 0xFF),
(uint8_t)((hp >> 8) & 0xFF),
(uint8_t)(hp & 0xFF) };
memcpy(*buf + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + 1, hp8, sizeof(float));
*buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + sizeof(float) + 1;
}
void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
@ -210,7 +220,8 @@ void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) {
size_t namesize = std::strlen(tinfo->name) + 1;
memcpy(*buf + 1, &tinfo->name, namesize);
strcpy(*buf + 1, namesize, tinfo->name);
uint64_t tid = tinfo->id;
uint8_t tid8[sizeof(uint64_t)] = {
(uint8_t)((tid >> 56) & 0xFF),
@ -233,7 +244,8 @@ void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) {
size_t namesize = std::strlen(linfo->name) + 1;
memcpy(*buf + 1, &linfo->name, namesize);
strcpy(*buf + 1, namesize, linfo->name);
uint64_t sid = linfo->sid;
uint8_t sid8[sizeof(uint64_t)] = {
(uint8_t)((sid >> 56) & 0xFF),
@ -270,7 +282,8 @@ void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) {
size_t namesize = std::strlen(pinfo->name) + 1;
memcpy(*buf + 1, &pinfo->name, namesize);
strcpy(*buf + 1, namesize, pinfo->name);
uint64_t id = pinfo->id;
uint8_t id8[sizeof(uint64_t)] = {
(uint8_t)((id >> 56) & 0xFF),
@ -397,11 +410,110 @@ void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) {
size_t messize = std::strlen(chat->mess) + 1;
memcpy(*buf + 1 + sizeof(uint64_t) * 3, &chat->mess, messize);
strcpy(*buf + 1 + sizeof(uint64_t) * 3, messize, chat->mess);
*buflen = messize + sizeof(uint64_t) * 3 + 2;
}
void netprot::Serialize(ChunkMod* chmod, char* buf[], uint32_t* buflen) {
*buf[0] = (char)netprot::PACKET_TYPE::CHUNKMOD;
uint32_t vec[3];
memcpy(vec, &chmod->pos, sizeof(Vector3f)); // Pour d<>naturer les floats.
uint8_t vec8[3 * sizeof(uint32_t)] = {
(uint8_t)((vec[0] >> 24) & 0xFF),
(uint8_t)((vec[0] >> 16) & 0xFF),
(uint8_t)((vec[0] >> 8) & 0xFF),
(uint8_t)(vec[0] & 0xFF),
(uint8_t)((vec[1] >> 24) & 0xFF),
(uint8_t)((vec[1] >> 16) & 0xFF),
(uint8_t)((vec[1] >> 8) & 0xFF),
(uint8_t)(vec[1] & 0xFF),
(uint8_t)((vec[2] >> 24) & 0xFF),
(uint8_t)((vec[2] >> 16) & 0xFF),
(uint8_t)((vec[2] >> 8) & 0xFF),
(uint8_t)(vec[2] & 0xFF) };
memcpy(*buf + 1, vec8, sizeof(uint32_t) * 3);
memcpy(*buf + sizeof(uint32_t) * 3 + 1, &chmod->b_type, sizeof(BlockType));
memcpy(*buf + sizeof(uint32_t) * 3 + 2, &chmod->old_b_type, sizeof(BlockType));
*buflen = sizeof(uint32_t) * 3 + 3;
}
void netprot::Serialize(BulletAdd* bull, char* buf[], uint32_t* buflen) {
*buf[0] = (char)netprot::PACKET_TYPE::BULLET;
uint64_t tstamp = bull->tstamp;
uint8_t ts8[sizeof(uint64_t)] = {
(uint8_t)((tstamp >> 56) & 0xFF),
(uint8_t)((tstamp >> 48) & 0xFF),
(uint8_t)((tstamp >> 40) & 0xFF),
(uint8_t)((tstamp >> 32) & 0xFF),
(uint8_t)((tstamp >> 24) & 0xFF),
(uint8_t)((tstamp >> 16) & 0xFF),
(uint8_t)((tstamp >> 8) & 0xFF),
(uint8_t)(tstamp & 0xFF)
};
memcpy(*buf + 1, ts8, sizeof(uint64_t));
uint64_t tid = bull->id;
uint8_t tid8[sizeof(uint64_t)] = {
(uint8_t)((tid >> 56) & 0xFF),
(uint8_t)((tid >> 48) & 0xFF),
(uint8_t)((tid >> 40) & 0xFF),
(uint8_t)((tid >> 32) & 0xFF),
(uint8_t)((tid >> 24) & 0xFF),
(uint8_t)((tid >> 16) & 0xFF),
(uint8_t)((tid >> 8) & 0xFF),
(uint8_t)(tid & 0xFF)
};
memcpy(*buf + 1 + sizeof(uint64_t), tid8, sizeof(uint64_t));
uint32_t vec[3];
memcpy(vec, &bull->pos, sizeof(Vector3f)); // Pour d<>naturer les floats.
uint8_t vec8[3 * sizeof(uint32_t)] = {
(uint8_t)((vec[0] >> 24) & 0xFF),
(uint8_t)((vec[0] >> 16) & 0xFF),
(uint8_t)((vec[0] >> 8) & 0xFF),
(uint8_t)(vec[0] & 0xFF),
(uint8_t)((vec[1] >> 24) & 0xFF),
(uint8_t)((vec[1] >> 16) & 0xFF),
(uint8_t)((vec[1] >> 8) & 0xFF),
(uint8_t)(vec[1] & 0xFF),
(uint8_t)((vec[2] >> 24) & 0xFF),
(uint8_t)((vec[2] >> 16) & 0xFF),
(uint8_t)((vec[2] >> 8) & 0xFF),
(uint8_t)(vec[2] & 0xFF) };
memcpy(*buf + 1 + sizeof(uint64_t) * 2, vec8, sizeof(uint32_t) * 3);
memcpy(vec, &bull->dir, sizeof(Vector3f)); // Pour d<>naturer les floats.
uint8_t dir8[3 * sizeof(uint32_t)] = {
(uint8_t)((vec[0] >> 24) & 0xFF),
(uint8_t)((vec[0] >> 16) & 0xFF),
(uint8_t)((vec[0] >> 8) & 0xFF),
(uint8_t)(vec[0] & 0xFF),
(uint8_t)((vec[1] >> 24) & 0xFF),
(uint8_t)((vec[1] >> 16) & 0xFF),
(uint8_t)((vec[1] >> 8) & 0xFF),
(uint8_t)(vec[1] & 0xFF),
(uint8_t)((vec[2] >> 24) & 0xFF),
(uint8_t)((vec[2] >> 16) & 0xFF),
(uint8_t)((vec[2] >> 8) & 0xFF),
(uint8_t)(vec[2] & 0xFF) };
memcpy(*buf + 1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 3, dir8, sizeof(uint32_t) * 3);
*buflen = 1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 6;
}
void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
*buf[0] = (char)netprot::PACKET_TYPE::ERRLOG;
@ -416,7 +528,7 @@ void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) {
bool netprot::Deserialize(Input* in, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(Input* in, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(Input))
return false;
@ -476,7 +588,7 @@ bool netprot::Deserialize(Input* in, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(Output* out, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(Output* out, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(Output))
return false;
@ -508,10 +620,12 @@ bool netprot::Deserialize(Output* out, char* buf, uint32_t *buflen) {
out->states.jumping = states & 0b10000000;
out->states.shooting = states & 0b01000000;
out->states.hit = states & 0b00100000;
out->states.dead = states & 0b00010000;
out->states.still = states & 0b00001000;
out->states.jumpshot = states & 0b00000100;
out->states.running = states & 0b00000010;
out->states.powerup = states & 0b00010000;
out->states.dead = states & 0b00001000;
out->states.still = states & 0b00000100;
out->states.jumpshot = states & 0b00000010;
out->states.running = states & 0b00000001;
uint8_t subvec[3 * sizeof(uint32_t)] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
memcpy(subvec, &buf[2 + sizeof(uint64_t) * 2], sizeof(uint8_t) * 12);
@ -553,7 +667,7 @@ bool netprot::Deserialize(Output* out, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(Sync* sync, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(Sync* sync, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(Sync))
return false;
@ -592,10 +706,9 @@ bool netprot::Deserialize(Sync* sync, char* buf, uint32_t *buflen) {
(uint16_t)diff[0] << 8 |
(uint16_t)diff[1];
memcpy(&sync->hp, &buf[1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t)], sizeof(uint8_t));
uint8_t subvec[3 * sizeof(uint32_t)] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
memcpy(subvec, &buf[2 + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t)], sizeof(uint8_t) * 12);
memcpy(subvec, &buf[1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t)], sizeof(uint8_t) * 12);
uint32_t vec[3] = {
(uint32_t)subvec[0] << 24 |
(uint32_t)subvec[1] << 16 |
@ -612,12 +725,23 @@ bool netprot::Deserialize(Sync* sync, char* buf, uint32_t *buflen) {
memcpy(&sync->position, vec, sizeof(uint32_t) * 3);
*buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + 2;
uint8_t hp8[4];
memcpy(&hp8, &buf[1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t)], sizeof(uint32_t));
uint32_t hp = (uint32_t)hp8[0] << 24 |
(uint32_t)hp8[1] << 16 |
(uint32_t)hp8[2] << 8 |
(uint32_t)hp8[3];
memcpy(&sync->hp, &hp, sizeof(float));
*buflen = 1 + sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + sizeof(float);
return true;
}
bool netprot::Deserialize(TeamInfo* tinfo, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(TeamInfo* tinfo, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(LoginInfo))
return false;
@ -626,7 +750,7 @@ bool netprot::Deserialize(TeamInfo* tinfo, char* buf, uint32_t *buflen) {
if (namesize > 32)
return false;
memcpy(&tinfo->name, &buf[1], namesize);
strcpy(tinfo->name, namesize, &buf[1]);
uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
@ -645,7 +769,7 @@ bool netprot::Deserialize(TeamInfo* tinfo, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(LoginInfo* linfo, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(LoginInfo* linfo, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(LoginInfo))
return false;
@ -654,7 +778,7 @@ bool netprot::Deserialize(LoginInfo* linfo, char* buf, uint32_t *buflen) {
if (namesize > 32)
return false;
memcpy(&linfo->name, &buf[1], namesize);
strcpy(linfo->name, namesize, &buf[1]);
uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
@ -684,7 +808,7 @@ bool netprot::Deserialize(LoginInfo* linfo, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(PlayerInfo* pinfo, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(PlayerInfo* pinfo, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(PlayerInfo))
return false;
@ -693,7 +817,7 @@ bool netprot::Deserialize(PlayerInfo* pinfo, char* buf, uint32_t *buflen) {
if (namesize > 32)
return false;
memcpy(&pinfo->name, &buf[1], namesize);
strcpy(pinfo->name, namesize, &buf[1]);
uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
memcpy(diff, &buf[namesize + 1], sizeof(uint64_t));
@ -723,7 +847,7 @@ bool netprot::Deserialize(PlayerInfo* pinfo, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(GameInfo* ginfo, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(GameInfo* ginfo, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(GameInfo))
return false;
@ -766,7 +890,7 @@ bool netprot::Deserialize(GameInfo* ginfo, char* buf, uint32_t *buflen) {
return true;
}
bool netprot::Deserialize(Chat* chat, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(Chat* chat, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(Chat))
return false;
@ -806,19 +930,119 @@ bool netprot::Deserialize(Chat* chat, char* buf, uint32_t *buflen) {
(uint64_t)dstt[6] << 8 |
(uint64_t)dstt[7];
size_t messsize = std::strlen(buf + sizeof(uint64_t) * 3) + 1;
size_t messsize = std::strlen(&buf[sizeof(uint64_t) * 3]) + 1;
if (messsize > 140)
return false;
memcpy(&chat->mess, &buf[1 + sizeof(uint64_t) * 3], messsize);
char* ciboire = &buf[1 + sizeof(uint64_t) * 3];
*buflen = messsize + sizeof(uint64_t) * 3 + 2;
strcpy(chat->mess, 140, ciboire);
//*buflen = messsize + sizeof(uint64_t) * 3 + 1;
return true;
}
bool netprot::Deserialize(ErrorLog* errlog, char* buf, uint32_t *buflen) {
bool netprot::Deserialize(ChunkMod* chmod, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(ChunkMod))
return false;
uint8_t subvec[3 * sizeof(uint32_t)] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
memcpy(subvec, &buf[1], sizeof(uint8_t) * 12);
uint32_t vec[3] = {
(uint32_t)subvec[0] << 24 |
(uint32_t)subvec[1] << 16 |
(uint32_t)subvec[2] << 8 |
(uint32_t)subvec[3],
(uint32_t)subvec[4] << 24 |
(uint32_t)subvec[5] << 16 |
(uint32_t)subvec[6] << 8 |
(uint32_t)subvec[7],
(uint32_t)subvec[8] << 24 |
(uint32_t)subvec[9] << 16 |
(uint32_t)subvec[10] << 8 |
(uint32_t)subvec[11] };
memcpy(&chmod->pos, vec, sizeof(uint32_t) * 3);
memcpy(&chmod->b_type, &buf[1 + sizeof(uint8_t) * 12], sizeof(BlockType));
memcpy(&chmod->old_b_type, &buf[2 + sizeof(uint8_t) * 12], sizeof(BlockType));
*buflen = sizeof(uint32_t) * 3 + 3;
return true;
}
bool netprot::Deserialize(BulletAdd* bull, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(BulletAdd))
return false;
uint8_t tst[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 };
memcpy(tst, &buf[1], sizeof(uint64_t));
bull->tstamp =
(uint64_t)tst[0] << 56 |
(uint64_t)tst[1] << 48 |
(uint64_t)tst[2] << 40 |
(uint64_t)tst[3] << 32 |
(uint64_t)tst[4] << 24 |
(uint64_t)tst[5] << 16 |
(uint64_t)tst[6] << 8 |
(uint64_t)tst[7];
memcpy(tst, &buf[1 + sizeof(uint64_t)], sizeof(uint64_t));
bull->id =
(uint64_t)tst[0] << 56 |
(uint64_t)tst[1] << 48 |
(uint64_t)tst[2] << 40 |
(uint64_t)tst[3] << 32 |
(uint64_t)tst[4] << 24 |
(uint64_t)tst[5] << 16 |
(uint64_t)tst[6] << 8 |
(uint64_t)tst[7];
uint8_t subvec[3 * sizeof(uint32_t)] = { 0,0,0,0,0,0,0,0,0,0,0,0 };
memcpy(subvec, &buf[1 + sizeof(uint64_t) * 2], sizeof(uint8_t) * 12);
uint32_t vec[3] = {
(uint32_t)subvec[0] << 24 |
(uint32_t)subvec[1] << 16 |
(uint32_t)subvec[2] << 8 |
(uint32_t)subvec[3],
(uint32_t)subvec[4] << 24 |
(uint32_t)subvec[5] << 16 |
(uint32_t)subvec[6] << 8 |
(uint32_t)subvec[7],
(uint32_t)subvec[8] << 24 |
(uint32_t)subvec[9] << 16 |
(uint32_t)subvec[10] << 8 |
(uint32_t)subvec[11] };
memcpy(&bull->pos, vec, sizeof(uint32_t) * 3);
memcpy(subvec, &buf[1 + sizeof(uint64_t) * 2 + sizeof(uint8_t) * 12], sizeof(uint8_t) * 12);
uint32_t dir[3] = {
(uint32_t)subvec[0] << 24 |
(uint32_t)subvec[1] << 16 |
(uint32_t)subvec[2] << 8 |
(uint32_t)subvec[3],
(uint32_t)subvec[4] << 24 |
(uint32_t)subvec[5] << 16 |
(uint32_t)subvec[6] << 8 |
(uint32_t)subvec[7],
(uint32_t)subvec[8] << 24 |
(uint32_t)subvec[9] << 16 |
(uint32_t)subvec[10] << 8 |
(uint32_t)subvec[11] };
memcpy(&bull->dir, dir, sizeof(uint32_t) * 3);
*buflen = 1 + sizeof(uint64_t) * 2 + sizeof(uint8_t) * 24;
return true;
}
bool netprot::Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen) {
if (*buflen <= sizeof(ErrorLog))
return false;
@ -845,7 +1069,7 @@ netprot::PACKET_TYPE netprot::getType(char* buf, const uint32_t buflen) {
return (netprot::PACKET_TYPE)buf[0];
}
netprot::Packet netprot::getPack(char* buf, uint32_t *buflen) {
netprot::Packet netprot::getPack(char* buf, uint32_t* buflen) {
Packet pck = { nullptr, PACKET_TYPE::ERR };
Input* in = nullptr;
Output* out = nullptr;
@ -911,9 +1135,7 @@ netprot::Packet netprot::getPack(char* buf, uint32_t *buflen) {
return pck;
}
netprot::Packet netprot::getPack(netprot::Buffer* buf) {
return netprot::getPack(buf->ptr, &buf->len);
}
netprot::Packet netprot::getPack(netprot::Buffer* buf) { return netprot::getPack(buf->ptr, &buf->len); }
bool netprot::emptyPack(netprot::Packet pck) {
switch (pck.type) {
@ -950,13 +1172,12 @@ netprot::Packet netprot::makePack(void* ptr, PACKET_TYPE type) {
return pck;
}
std::vector<char*> netprot::recvPacks(SOCKET sock, Buffer* buf, Buffer* outbuf) {
std::vector<char*> lsPck;
int len = buf->tmp? buf->tmp - buf->ptr: 0,
void netprot::recvPacks(SOCKET sock, Buffer* buf, std::vector<char*>* lsPck) {
int len = buf->tmp ? buf->tmp - buf->ptr : 0,
end = 0;
char * cursor = buf->tmp ? buf->tmp: nullptr ,
* next = buf->tmp ? buf->tmp + 1: buf->ptr,
* last = buf->tmp ? buf->tmp: buf->ptr;
char* cursor = buf->tmp ? buf->tmp : nullptr,
* next = buf->tmp ? buf->tmp + 1 : buf->ptr,
* last = buf->tmp ? buf->tmp : buf->ptr;
bool ended = true;
struct pollfd fds[1];
@ -967,14 +1188,14 @@ std::vector<char*> netprot::recvPacks(SOCKET sock, Buffer* buf, Buffer* outbuf)
if (!poll(fds, 1, 0)) {
if (ended)
buf->tmp = nullptr;
return lsPck;
return;
}
int bytes = recv(sock, &buf->ptr[len], buf->len - len, 0);
if (bytes <= 0) { // si recv() retourne -1 ou 0; ça veut dire qu'il y a plus rien a lire qui n'a pas déjà été traité.
if (ended)
buf->tmp = nullptr;
return lsPck;
return;
}
len += bytes;
end = len;
@ -998,24 +1219,14 @@ std::vector<char*> netprot::recvPacks(SOCKET sock, Buffer* buf, Buffer* outbuf)
cmp = memcmp(cursor, Footer, sizeof(uint32_t));
if (cmp == 0) {
if (!outbuf) {
lsPck.push_back(last);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
else {
memcpy(&outbuf->ptr[cursor - last], last, cursor - last);
lsPck.push_back(&outbuf->ptr[cursor - last]);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
lsPck->push_back(last);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
}
else {
if (!outbuf)
buf->tmp = last;
buf->tmp = last;
cursor = &buf->ptr[len];
next = cursor + 1;
break;
@ -1024,8 +1235,7 @@ std::vector<char*> netprot::recvPacks(SOCKET sock, Buffer* buf, Buffer* outbuf)
}
}
std::vector<char*> netprot::recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, Buffer* outbuf) {
std::vector<char*> lsPck;
void netprot::recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, std::vector<char*>* lsPck) {
int len = buf->tmp ? buf->tmp - buf->ptr : 0,
end = 0;
char* cursor = buf->tmp ? buf->tmp : nullptr,
@ -1043,14 +1253,14 @@ std::vector<char*> netprot::recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in
if (!poll(fds, 1, 0)) {
if (ended)
buf->tmp = nullptr;
return lsPck;
return;
}
int bytes = recvfrom(sock, &buf->ptr[len], buf->len - len, 0, (sockaddr*)&sockad, &socklen);
if (bytes <= 0) { // si recv() retourne -1 ou 0; ça veut dire qu'il y a plus rien a lire qui n'a pas déjà été traité.
if (ended)
buf->tmp = nullptr;
return lsPck;
return;
}
len += bytes;
end = len;
@ -1074,24 +1284,14 @@ std::vector<char*> netprot::recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in
cmp = memcmp(cursor, Footer, sizeof(uint32_t));
if (cmp == 0) {
if (!outbuf) {
lsPck.push_back(last);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
else {
memcpy(&outbuf->ptr[cursor - last], last, cursor - last);
lsPck.push_back(&outbuf->ptr[cursor - last]);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
lsPck->push_back(last);
cursor += sizeof(uint32_t);
last = cursor;
next = cursor + 1;
}
}
else {
if (!outbuf)
buf->tmp = last;
buf->tmp = last;
cursor = &buf->ptr[len];
next = cursor + 1;
break;

91
SQCSim-common/netprotocol.h
View File

@ -12,14 +12,14 @@ namespace netprot {
ERR, INPUT, OUTPUT, SYNC,
TEAMINF, SELFINF, PLAYINF, LOGINF,
CHUNKMOD, PLAYERMOD, PICKUPMOD,
GAMEINFO, ENDINFO , CHAT, ERRLOG,
LAST_PACK
GAMEINFO, ENDINFO , BULLET,
CHAT, ERRLOG, LAST_PACK
};
/* Structures */
struct Buffer { // Pour pouvoir rendre l'utilisation des buffers plus clean.
char* ptr = new char[BUFFER_LENGTH] { 1 }, * tmp = nullptr;
char *ptr = new char[BUFFER_LENGTH] { 1 }, *tmp = nullptr;
uint32_t len = BUFFER_LENGTH;
~Buffer() { delete[] ptr; }
@ -27,7 +27,7 @@ namespace netprot {
};
struct Packet { // Pour pouvoir recevoir les paquets du recv() sans avoir à les aiguiller dans la même thread.
void* ptr = nullptr; // Notez que le pointeur doit être supprimé séparément lorsqu'il n'est plus utile.
void *ptr = nullptr; // Notez que le pointeur doit être supprimé séparément lorsqu'il n'est plus utile.
PACKET_TYPE type = PACKET_TYPE::ERR;
};
@ -38,24 +38,24 @@ namespace netprot {
/* Sous-structures */
struct Keys {
bool forward,
backward,
left,
right,
jump,
shoot,
block;
bool forward = false,
backward = false,
left = false,
right = false,
jump = false,
shoot = false,
block = false;
};
struct States {
bool jumping,
shooting,
hit,
powerup,
dead,
still,
jumpshot,
running;
bool jumping = false,
shooting = false,
hit = false,
powerup = false,
dead = false,
still = false,
jumpshot = false,
running = false;
};
/* Structures de paquets */
@ -80,37 +80,37 @@ namespace netprot {
uint64_t sid = 0;
uint32_t timer = 0;
uint16_t ammo = 0;
uint8_t hp = 0;
float hp = 0;
Vector3f position;
Sync() {}
Sync(Sync* sync) : timestamp(sync->timestamp), sid(sync->sid), timer(sync->timer), ammo(sync->ammo), hp(sync->hp), position(sync->position) {}
};
struct TeamInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t id = 0;
TeamInfo() {}
TeamInfo(TeamInfo* tem) : id(tem->id) { strcpy(tem->name, name); }
TeamInfo(TeamInfo* tem) : id(tem->id) { strcpy(name, 32, tem->name); }
~TeamInfo() { delete[] name; }
};
struct LoginInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t sid = 0,
tid = 0;
LoginInfo() {}
LoginInfo(LoginInfo* ply): sid(ply->sid), tid(ply->tid) { strcpy(ply->name, name); }
LoginInfo(LoginInfo* log): sid(log->sid), tid(log->tid) { strcpy(name, 32, log->name); }
~LoginInfo() { delete[] name; }
};
struct PlayerInfo { // cli <-> srv TCP once
char name[32];
char *name = new char[32];
uint64_t id = 0,
tid = 0;
PlayerInfo() {}
PlayerInfo(PlayerInfo* log) : id(log->id), tid(log->tid) {
strcpy(log->name, name);
};
PlayerInfo(int id, int tid, std::string strname) : id(id), tid(tid) { memcpy((void*)strname.c_str(), name, strname.length());
}
PlayerInfo(PlayerInfo* ply) : id(ply->id), tid(ply->tid) { strcpy(name, 32, ply->name); };
PlayerInfo(int id, int tid, std::string strname) : id(id), tid(tid) { strcpy(name, 32, strname.c_str()); }
~PlayerInfo() { delete[] name; }
};
struct GameInfo { // cli <-> srv TCP event (before game start)/ once
@ -125,16 +125,29 @@ namespace netprot {
uint64_t src_id = 0,
dest_id = 0,
dest_team_id = 0;
char mess[140]; // Good 'nough for twitr, good 'nough for me.
char *mess = new char[140]; // Good 'nough for twitr, good 'nough for me.
Chat() {}
Chat(Chat* cha) : src_id(cha->src_id), dest_id(cha->dest_id), dest_team_id(cha->dest_team_id) { strcpy(cha->mess, mess); }
Chat(Chat* cha) : src_id(cha->src_id), dest_id(cha->dest_id), dest_team_id(cha->dest_team_id) { strcpy(mess, 140, cha->mess); }
~Chat() { delete[] mess; }
};
struct ChunkMod {
Vector3f pos;
BlockType b_type, old_b_type;
};
struct BulletAdd {
Timestamp tstamp;
Vector3f pos, dir;
uint64_t id;
};
struct ErrorLog { // srv -> cli TCP event
char mess[140];
bool is_fatal;
char *mess = new char[140];
bool is_fatal = false;
ErrorLog() {};
ErrorLog(ErrorLog* err) : is_fatal(err->is_fatal) { strcpy(err->mess, mess); }
ErrorLog(ErrorLog* err) : is_fatal(err->is_fatal) { strcpy(mess, 140, err->mess); }
~ErrorLog() { delete[] mess; }
};
/* Fonctions */
@ -147,6 +160,8 @@ namespace netprot {
void Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen); // srv
void Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen); // cli/srv
void Serialize(Chat* chat, char* buf[], uint32_t* buflen); // cli/srv
void Serialize(ChunkMod* chmod, char* buf[], uint32_t* buflen); // srv
void Serialize(BulletAdd* bull, char* buf[], uint32_t* buflen); // srv
void Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen); // srv
bool Deserialize(Input* in, char* buf, uint32_t* buflen); // srv
@ -157,6 +172,8 @@ namespace netprot {
bool Deserialize(PlayerInfo* pinfo, char* buf, uint32_t* buflen); // cli
bool Deserialize(GameInfo* ginfo, char* buf, uint32_t* buflen); // cli
bool Deserialize(Chat* chat, char* buf, uint32_t* buflen); // srv/cli
bool Deserialize(ChunkMod* chmod, char* buf, uint32_t* buflen); // cli
bool Deserialize(BulletAdd* bull, char* buf, uint32_t* buflen); // cli
bool Deserialize(ErrorLog* errlog, char* buf, uint32_t* buflen); // srv
PACKET_TYPE getType(char* buf, uint32_t buflen);
@ -176,8 +193,8 @@ namespace netprot {
template <class T> void sendPack(SOCKET sock, T* pack, Buffer* buf);
template <class T> void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad);
std::vector<char*> recvPacks(SOCKET sock, Buffer* buf, Buffer* oufbuf = nullptr);
std::vector<char*> recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, Buffer* oufbuf = nullptr);
void recvPacks(SOCKET sock, Buffer* buf, std::vector<char*>* lsPck);
void recvPacksFrom(SOCKET sock, Buffer* buf, sockaddr_in from, std::vector<char*>* lsPck);
/* Templates */

78
SQCSim-common/player.cpp
View File

@ -14,43 +14,53 @@ void Player::TurnLeftRight(float value) {
m_rotY += value;
if (m_rotY > 360) m_rotY = 0;
else if (m_rotY < -360) m_rotY = 0;
float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
float xrotrad = (m_rotX / 57.2957795056f);
m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
-sin(xrotrad),
cos(xrotrad) * -cos(yrotrad));
m_direction.Normalize();
}
void Player::TurnTopBottom(float value) {
m_rotX += value;
if (m_rotX > 80) m_rotX = 80;
else if (m_rotX < -80) m_rotX = -80;
}
Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
Vector3f delta = Vector3f(0, 0, 0);
float yrotrad = (m_rotY / 57.2957795056f); // 180/Pi = 57.295...
float xrotrad = (m_rotX / 57.2957795056f);
m_direction = Vector3f(cos(xrotrad) * sin(yrotrad),
-sin(xrotrad),
cos(xrotrad) * -cos(yrotrad));
-sin(xrotrad),
cos(xrotrad) * -cos(yrotrad));
m_direction.Normalize();
}
Vector3f Player::GetInput(bool front, bool back, bool left, bool right, bool jump, bool shoot, float elapsedTime) {
Vector3f delta = Vector3f(0, 0, 0);
Vector3f dir = m_direction;
dir.y = 0;
if (front) {
delta.x += float(sin(yrotrad)) * elapsedTime * 10.f;
delta.z += float(-cos(yrotrad)) * elapsedTime * 10.f;
delta += dir;
}
else if (back) {
delta.x += float(-sin(yrotrad)) * elapsedTime * 10.f;
delta.z += float(cos(yrotrad)) * elapsedTime * 10.f;
delta -= dir;
}
if (left) {
delta.x += float(-cos(yrotrad)) * elapsedTime * 10.f;
delta.z += float(-sin(yrotrad)) * elapsedTime * 10.f;
delta.x += dir.z;
delta.z += -dir.x;
}
else if (right) {
delta.x += float(cos(yrotrad)) * elapsedTime * 10.f;
delta.z += float(sin(yrotrad)) * elapsedTime * 10.f;
delta.x -= dir.z;
delta.z -= -dir.x;
}
delta.Normalize();
@ -194,11 +204,11 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi
void Player::ApplyTransformation(Transformation& transformation, bool rel, bool rot) const {
transformation.ApplyRotation(-m_rotX, 1, 0, 0);
transformation.ApplyRotation(-m_rotY, 0, 1, 0);
if (rel) transformation.ApplyTranslation(-GetPOV());
if (!rot) {
transformation.ApplyRotation(-m_rotX, 1, 0, 0);
transformation.ApplyRotation(-m_rotY, 0, 1, 0);
}
}
void Player::GetBooster(Booster boosttype)
@ -246,8 +256,12 @@ void Player::RemoveBooster(float elapsedtime)
}
void Player::SetDirection(Vector3f dir) { m_direction = dir; }
void Player::Move(Vector3f diff) { m_position -= diff; }
Vector3f Player::GetPosition() const { return Vector3f(m_position.x + CHUNK_SIZE_X * WORLD_SIZE_X / 2, m_position.y, m_position.z + CHUNK_SIZE_Z * WORLD_SIZE_Y / 2); }
Vector3f Player::GetPositionAbs() const { return m_position; }
Vector3f Player::GetVelocity() const { return m_velocity; }
Vector3f Player::GetPOV() const { return Vector3f(GetPosition().x, m_POV, GetPosition().z); }
@ -262,26 +276,24 @@ void Player::Teleport(int& x, int& z) {
m_position.x -= x * CHUNK_SIZE_X;
m_position.z -= z * CHUNK_SIZE_Z;
}
bool Player::AmIDead()
{
return m_hp <= 0;
}
bool Player::GetIsAirborne() const { return m_airborne; }
bool Player::AmIDead() { return m_hp <= 0; }
void Player::InflictDamage(float hitPoints)
{
void Player::InflictDamage(float hitPoints) {
m_hp -= hitPoints;
if (AmIDead())
{ // Quand le joueur est mort.
}
if (m_hp < 0)
m_hp == 0;
//if (AmIDead())
//{ // Quand le joueur est mort.
//}
}
int Player::getScore() const { return m_score; }
void Player::addPoint() { ++m_score; }
uint64_t Player::getId() const { return id; }

10
SQCSim-common/player.h
View File

@ -25,7 +25,9 @@ public:
void ApplyTransformation(Transformation& transformation, bool rel = true, bool rot = true) const;
void SetDirection(Vector3f dir);
void Move(Vector3f diff);
Vector3f GetPosition() const;
Vector3f GetPositionAbs() const;
Vector3f GetDirection() const;
Vector3f GetVelocity() const;
Vector3f GetPOV() const;
@ -33,8 +35,14 @@ public:
float GetHP() const;
void Teleport(int& x, int& z);
bool GetIsAirborne() const;
bool AmIDead();
void InflictDamage(float hitPoints);
int getScore() const;
void addPoint();
uint64_t Killer = 0;
std::string m_username;
bool m_hit = false;
private:
uint64_t getId() const;
@ -44,8 +52,8 @@ protected:
Vector3f m_velocity;
Vector3f m_direction;
std::string m_username;
uint64_t id = 0;
int m_score = 0;
float m_rotX = 0;
float m_rotY = 0;

32
SQCSim-common/world.cpp
View File

@ -169,31 +169,26 @@ void World::Update(Bullet* bullets[MAX_BULLETS], const Vector3f& player_pos, Blo
UpdateWorld(player_pos, blockinfo);
//TransposeWorld(player_pos, bullets);
}
//
//void World::UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]) {
// if (updates == 0 && ChunkAt(chx, 1, chy) &&
// ChunkAt(chx, 1, chy)->IsDirty()) {
// ChunkAt(chx, 1, chy)->Update(blockinfo, this);
// updates = FRAMES_UPDATE_CHUNKS;
// }
//
//}
void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block) {
netprot::ChunkMod* World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block, bool net) {
Vector3f currentPos = player_pos;
Vector3f currentBlock = currentPos;
Vector3f ray = player_dir;
BlockType oldbtype;
netprot::ChunkMod* cmod = nullptr;
bool found = false;
if (block) return;
if (block) return cmod;
while ((currentPos - currentBlock).Length() <= MAX_SELECTION_DISTANCE && !found) {
currentBlock += ray / 10.f;
BlockType bt = BlockAt(currentBlock);
if (bt != BTYPE_AIR)
if (bt != BTYPE_AIR) {
found = true;
oldbtype = bt;
}
}
if (found)
@ -219,21 +214,30 @@ void World::ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos,
(By == PyA ||
By == PyB ||
By == PyC) &&
Bz == Pz))
Bz == Pz)) {
found = true;
oldbtype = bt;
}
}
}
}
if (found && (int)currentBlock.y < CHUNK_SIZE_Y) {
if (net) {
cmod = new netprot::ChunkMod();
cmod->old_b_type = oldbtype;
cmod->b_type = blockType;
cmod->pos = currentBlock;
}
int bx = (int)currentBlock.x % CHUNK_SIZE_X;
int by = (int)currentBlock.y % CHUNK_SIZE_Y;
int bz = (int)currentBlock.z % CHUNK_SIZE_Z;
ChunkAt(currentBlock)->SetBlock(bx, by, bz, blockType, this);
ChunkAt(currentBlock)->MakeModified();
block = true;
}
return cmod;
}
void World::ChangeBlockAtPosition(BlockType blockType, Vector3f pos) {

3
SQCSim-common/world.h
View File

@ -11,6 +11,7 @@
#include "array2d.h"
#include "bullet.h"
#include "chunk.h"
#include "netprotocol.h"
class Chunk;
class Bullet;
@ -37,7 +38,7 @@ public:
void GetScope(unsigned int& x, unsigned int& y);
void ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block);
netprot::ChunkMod* ChangeBlockAtCursor(BlockType blockType, const Vector3f& player_pos, const Vector3f& player_dir, bool& block, bool net);
void ChangeBlockAtPosition(BlockType blockType, Vector3f pos);
void CleanUpWorld(int& deleteframes, bool clear);
int GettbDeleted() const;

2
SQCSim-srv/SQCSim-srv.vcxproj
View File

@ -48,7 +48,7 @@
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>Application</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<PlatformToolset>v143</PlatformToolset>
<PlatformToolset>ClangCL</PlatformToolset>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
</PropertyGroup>

175
SQCSim-srv/connection.cpp
View File

@ -3,25 +3,27 @@
Connection::Connection(SOCKET sock,
sockaddr_in sockaddr,
LoginInfo log,
PlayerInfo play):
sockaddr_in sockaddr,
LoginInfo *log,
PlayerInfo *play) :
m_sock(sock),
m_addr(sockaddr),
m_loginfo(log),
m_playinfo(play) {
m_loginfo(*log),
m_playinfo(*play) {
}
Connection::~Connection() { closesocket(m_sock); }
Connection::~Connection() {
delete player;
closesocket(m_sock); }
uint64_t Connection::GetHash(bool self) const { return self? m_loginfo.sid: m_playinfo.id; }
uint64_t Connection::GetHash(bool self) const { return self ? m_loginfo.sid : m_playinfo.id; }
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 }); }
void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); m_input_vector.push_back(in); }
Output* Connection::getOutput(Timestamp time) {
auto out = m_output_manifest.find(time);
@ -50,70 +52,157 @@ sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; }
void Connection::getPacks(SOCKET sock) {
std::vector<char*> lsPck;
Input in;
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))
m_input_manifest[in.timestamp] = in;
break;
default: break;
Sync sync;
recvPacksFrom(sock, &m_buf, m_addr, &lsPck);
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);
}
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize))
m_nsync = true;
break;
default: break;
}
lsPck.clear();
}
lsPck.clear();
}
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++);
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(true))
if (m_playinfo.id == conn->GetHash(false))
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->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();
}
}
void Connection::Run(World* world) {
Timestamp Connection::Run(World* world) {
Input in, last;
Output out;
Timestamp tstamp = 0;
float el;
if (m_input_manifest.size() < 2)
return;
return tstamp;
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);
if (player->AmIDead()) {
m_input_manifest.clear();
return tstamp;
}
el = (float)(in.timestamp - last.timestamp) / 1000.;
player.get()->SetDirection(in.direction);
player.get()->ApplyPhysics(player.get()->GetInput(in.keys.forward,
in.keys.backward,
in.keys.left,
in.keys.right,
in.keys.jump, false, el), world, el);
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);
out.position = player.get()->GetPosition();
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;
}
player->SetDirection(in.direction);
player->ApplyPhysics(player->GetInput(in.keys.forward,
in.keys.backward,
in.keys.left,
in.keys.right,
in.keys.jump, false, el), world, el);
if (player->GetPosition().y < -20.) {
player->InflictDamage(9000.);
player->Killer = GetHash(true);
}
out.states.jumping = player->GetIsAirborne();
out.states.running = player->GetVelocity().Length() > .5f;
out.states.still = !out.states.running && !out.states.jumping;
out.states.hit = player->m_hit;
player->m_hit = false;
if (player->AmIDead()) {
in.keys.shoot = false;
in.keys.block = false;
out.states.dead = true;
}
static bool toggle = false;
if (in.keys.block) {
if (!toggle) {
toggle = true;
bool block = false;
ChunkMod* cmod = world->ChangeBlockAtCursor(BLOCK_TYPE::BTYPE_METAL,
player->GetPosition(),
player->GetDirection(),
block, true);
if (cmod)
ChunkDiffs.push_back(std::move(cmod));
}
}
else toggle = false;
out.states.shooting = in.keys.shoot;
if (out.states.jumping && out.states.shooting)
out.states.jumpshot = true;
else out.states.jumpshot = false;
if (in.keys.shoot && m_shoot_acc <= 0.) {
Bullets.push_back(std::move(new Bullet(player->GetPOV() + player->GetDirection(), player->GetDirection(), GetHash(true))));
m_shoot_acc = BULLET_TIME;
}
out.position = player->GetPositionAbs();
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);
tstamp = out.timestamp;
++m_last_in;
}
return tstamp;
}
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--);
}
Timestamp Connection::GetTStamp() const { return m_tstamp; }

23
SQCSim-srv/connection.h
View File

@ -16,11 +16,11 @@ public:
Connection(
SOCKET sock,
sockaddr_in sockaddr,
LoginInfo log,
PlayerInfo play);
LoginInfo *log,
PlayerInfo *play);
~Connection();
std::unique_ptr<Player> player = nullptr;
Player* player = nullptr;
uint64_t GetHash(bool self = true) const;
uint64_t GetTeamHash() const;
@ -34,16 +34,29 @@ public:
sockaddr_in* getAddr() const;
void getPacks(SOCKET sock);
void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns);
void sendPacks(SOCKET sock, std::unordered_map<uint64_t, Connection*> conns, const uint32_t timer);
void Run(World* world);
Timestamp Run(World* world);
void CleanInputManifest(Timestamp time);
bool m_nsync = true;
std::vector<Bullet*> Bullets;
std::vector<ChunkMod*> ChunkDiffs;
Timestamp GetTStamp() const;
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;
Timestamp m_tstamp = 0;
SOCKET m_sock;
sockaddr_in m_addr;
LoginInfo m_loginfo;

16
SQCSim-srv/define.h
View File

@ -11,4 +11,20 @@
#define ID_LIST_SIZE 127
#define SRV_MANUAL_SETUP true
// @ = Dead guy, $ = Killer.
const std::vector<std::string> DEATHMESSAGES = { "@ has gone to meet their maker.",
"@ has bit the dust, if you know what I mean.",
"@ has ceased to be.",
"@ is no more.",
"@ is like, super dead.",
"Requiescat In Pace, @.",
"So long, @, and thanks for all the lols!",
"@ has a bad case of being dead.",
"@ has finally seen the light!",
"Thought @ was hot; guess what? He's not. He is dead, dead, dead.",
"@ did not want to live forever.",
"$ made @ die for their country.",
"$ has become death, destroyer of @.",
"$ did not make @ feel lucky." };
#endif

7
SQCSim-srv/main.cpp
View File

@ -3,6 +3,11 @@
int main() {
std::unique_ptr<Server> server = std::make_unique<Server>();
if (server->Init() == 0)
if (server->Ready() == 0)
while (server->Ready() == 0) {
server->Run();
if (!server->NewGameRequested())
break;
server->Cleanup();
}
server->DeInit();
}

347
SQCSim-srv/server.cpp
View File

@ -18,9 +18,10 @@ Server::~Server() {
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
for (const auto& [key, player] : m_players)
closesocket(player->getSock());
m_players.clear();
for (const auto& [key, player] : m_conns)
closesocket(player->getSock());
m_conns.clear();
delete m_world;
#ifdef _WIN32
WSACleanup();
#endif
@ -76,27 +77,31 @@ int Server::Ready() {
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
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;
}
} while (m_game.countdown < 1);
do {
m_game.seed = 9370707;
/*do {
Log("Entrez le seed de la partie: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
m_game.seed = std::stoi(m_buf.ptr);
} catch(const std::exception& e) {
std::stoi(m_buf.ptr);
}
catch (const std::exception& e) {
Log(e.what(), true, false);
m_game.seed = 0;
}
} while (m_game.seed < 1);
} while (m_game.seed < 1);*/
do {
Log("Entrez le nombre de joueurs: ", false, false);
std::cin.getline(m_buf.ptr, BUFFER_LENGTH);
try {
nbrjoueurs = std::stoi(m_buf.ptr);
} catch(const std::exception& e) {
}
catch (const std::exception& e) {
Log(e.what(), true, false);
nbrjoueurs = 0;
}
@ -127,7 +132,7 @@ int Server::Ready() {
str.append(inet_ntop(AF_INET, &sockad.sin_addr, m_buf.ptr, m_buf.len)).append(": ").append(std::to_string(sockad.sin_port));
if (recv(sock, m_buf.ptr, m_buf.len, 0) > 0) {
PlayerInfo play;
PlayerInfo* play = new PlayerInfo();
m_buf.len = BUFFER_LENGTH;
Packet pck = getPack(&m_buf);
@ -145,32 +150,35 @@ 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);
sendPack<LoginInfo>(sock, log, &m_buf);
sendPackTo<LoginInfo>(m_sock_udp, log, &m_buf, &sockad);
play.id = getUniqueId();
strcpy(play.name, log->name);
play->id = getUniqueId();
play->tid = log->tid;
strcpy(play->name, 32, log->name);
play.tid = log->tid;
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;
sendPack<GameInfo>(sock, &m_game, &m_buf);
Connection* conn = new Connection(sock, sockad, *log, play);
sendPackTo<GameInfo>(m_sock_udp, &m_game, &m_buf, &sockad);
Connection* conn = new Connection(sock, sockad, log, play);
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;
m_conns[log->sid] = conn;
if (++nbrconn >= nbrjoueurs)
readystart = true;
}
}
}
for (auto& [keyin, playin] : m_conns) // Not pretty, but it works.
for (auto& [keyout, playout] : m_conns) {
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;
}
@ -182,62 +190,229 @@ void Server::Run() {
Log("Debut de la partie...", false, false);
int players = m_players.size();
int players = m_conns.size();
m_world = new World();
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.
conn->player = std::make_unique<Player>(Vector3f(8.5f, CHUNK_SIZE_Y + 1.8f, 8.5f));
for (auto& [key, conn] : m_conns) { // Creation des instances de joueurs et premier sync.
if (!conn) {
m_conns.erase(key);
continue;
}
int x = (rand() % (CHUNK_SIZE_X * WORLD_SIZE_X - 1) - (CHUNK_SIZE_X * WORLD_SIZE_X / 2)) / 8,
y = (rand() % (CHUNK_SIZE_Y * WORLD_SIZE_Y - 1) - (CHUNK_SIZE_Y * WORLD_SIZE_Y / 2)) / 8;
conn->player = new Player(Vector3f(x + .5f, CHUNK_SIZE_Y + 1.8f, y + .5f));
conn->player->m_username = conn->GetName();
m_players[key] = conn->player;
Sync sync;
sync.position = conn->player->GetPosition();
sync.position = conn->player->GetPositionAbs();
sync.hp = conn->player->GetHP();
sync.sid = key;
sync.ammo = 0;
sync.timestamp = 0;
sync.timer = m_game.countdown;
sendPack<Sync>(conn->getSock(), &sync, &m_buf);
sendPackTo<Sync>(m_sock_udp, &sync, &m_buf, conn->getAddr());
}
int timer = m_game.countdown, sync_acc = 0, deadplayers = 0;
std::chrono::high_resolution_clock::time_point start = std::chrono::high_resolution_clock::now();
Timestamp last = 0;
std::vector<Chat*> chatlog;
std::vector<ChunkMod*> chunkdiffs;
std::vector<Bullet*> bullets;
std::vector<std::vector<Bullet*>::iterator> bullit;
std::vector<BulletAdd*> netbull;
std::vector<char*> lsPck;
Chat* startchat = new Chat();
startchat->src_id = 0;
char startmess[] = "How would -YOU- like to die today, motherf-words?";
strcpy(startchat->mess, 140, startmess);
chatlog.emplace_back(startchat);
while (!endgame) {
for (auto& [key, conn] : m_players) {
conn->getPacks(m_sock_udp);
conn->Run(m_world);
conn->sendPacks(m_sock_udp, m_players);
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) {
while (sync_acc >= 1000)
sync_acc -= 1000;
--timer;
std::string str = "Timer: ";
Log(str.append(std::to_string(timer)), false, false);
}
last = tstamp;
for (auto& [key, conn] : m_conns) {
/* In */
Input in; Sync sync;
recvPacks(m_sock_udp, &m_buf, &lsPck);
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 (m_conns.count(in.sid))
m_conns[in.sid]->AddInput(in);
}
break;
case SYNC:
if (Deserialize(&sync, pck, &bsize)) {}
break;
default: break;
}
}
lsPck.clear();
/* Process */
if (conn->m_nsync) {
Timestamp tstamp = conn->Run(m_world);
if (conn->player->AmIDead()) {
Chat* chat = new Chat();
chat->dest_id = chat->dest_team_id = chat->src_id = 0;
std::string killer = m_conns.at(conn->player->Killer)->player->GetUsername();
std::string mess = getDeathMessage(conn->player->GetUsername(), killer);
strcpy(chat->mess, 140, mess.c_str());
chatlog.emplace_back(chat);
++deadplayers;
conn->m_nsync = false;
}
else {
for (auto& chmo : conn->ChunkDiffs)
chunkdiffs.emplace_back(std::move(chmo));
conn->ChunkDiffs.clear();
for (auto& bull : conn->Bullets) {
bullets.emplace_back(bull);
//Log("POW!", false, false);
BulletAdd* nbul = new BulletAdd();
nbul->pos = bull->getPos();
nbul->dir = bull->getVel();
nbul->id = key;
nbul->tstamp = tstamp;
netbull.emplace_back(std::move(nbul));
}
conn->Bullets.clear();
}
/* Out */
conn->sendPacks(m_sock_udp, m_conns, timer);
}
if ((deadplayers == players - 1 && deadplayers != 0) || timer <= 0)
endgame = true;
}
for (auto& bull : netbull) {
for (auto& [key, conn] : m_conns)
if (bull->id != conn->GetHash(false)) // Pour pas repitcher au joueur sa propre balle.
sendPackTo<BulletAdd>(m_sock_udp, bull, &m_buf, conn->getAddr());
delete bull;
}
netbull.clear();
for (auto bull = bullets.begin(); bull != bullets.end(); ++bull) {
ChunkMod* cmod = nullptr;
Bullet* bullet = *bull;
if (bullet->Update(m_world, (1. / 60.), 20, m_players, &cmod)) {
if (cmod)
chunkdiffs.emplace_back(cmod);
bullit.push_back(bull);
delete bullet;
}
}
for (auto& bull: bullit)
bullets.erase(bull);
bullit.clear();
for (auto& chat : chatlog) {
Log(chat->mess, false, false);
for (auto& [key, conn] : m_conns)
sendPackTo<Chat>(m_sock_udp, chat, &m_buf, conn->getAddr());
delete chat;
}
chatlog.clear();
for (auto& chmo : chunkdiffs) {
for (auto& [key, conn] : m_conns)
sendPackTo<ChunkMod>(m_sock_udp, chmo, &m_buf, conn->getAddr());
delete chmo;
}
chunkdiffs.clear();
}
//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);
// }
//}
Chat end;
end.src_id = 0;
char endmess[] = "Game over, man. Game over.";
strcpy(end.mess, 140, endmess);
for (auto& [key, conn] : m_conns) {
std::string str = conn->player->GetUsername();
Log(str.append(" ").append(std::to_string(conn->player->GetHP())), false, false);
}
for (auto& [key, conn] : m_conns)
sendPackTo<Chat>(m_sock_udp, &end, &m_buf, conn->getAddr());
// TODO: Gérer les 2-3 secondes post-game avant le billboard pour pas avoir un whiplash à la fin de la game.
char* ch = new char[2];
std::cout << "Nouvelle partie? [o/N] ";
std::cin.getline(ch, 2);
std::cout << std::endl;
m_exit = true;
if (ch[0] == 'o' || ch[0] == 'O')
m_exit = false;
delete[] ch;
}
void Server::Cleanup() {
for (auto& [key, conn] : m_conns)
delete conn;
m_conns.clear();
m_players.clear();
delete m_world;
m_world = nullptr;
}
void Server::DeInit() {
if (m_logfile.is_open())
m_logfile.close();
if (m_sock_udp)
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
#ifdef _WIN32
WSACleanup();
#endif
}
bool Server::NewGameRequested() const { return !m_exit; }
inline std::string Server::LogTimestamp() {
time_t rawtime;
tm timeinfo;
@ -260,13 +435,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) {
@ -276,10 +451,11 @@ void Server::Log(std::string str, bool is_error = false, bool is_fatal = false)
closesocket(m_sock_udp);
if (m_sock_tcp)
closesocket(m_sock_tcp);
for (const auto& [key, player] : m_players) {
for (const auto& [key, player] : m_conns)
closesocket(player->getSock());
}
m_players.clear();
delete m_world;
m_conns.clear();
#ifdef _WIN32
WSACleanup();
#endif
@ -302,3 +478,34 @@ uint64_t Server::getUniqueId() {
m_ids.pop_back();
return id;
}
std::string Server::getDeathMessage(std::string username, std::string killer) const {
std::string mess;
std::string temp = DEATHMESSAGES.at(rand() % DEATHMESSAGES.size());
size_t ind = temp.find('@');
size_t indk = temp.find('$');
bool bypass = false;
if (indk == std::string::npos)
bypass = true;
if (ind < indk || bypass) {
mess.append(temp.substr(0, ind));
mess.append(username);
if (!bypass) {
mess.append(temp.substr(ind + 1, indk - 1));
mess.append(killer);
mess.append(temp.substr(indk + 1));
}
else mess.append(temp.substr(ind + 1));
}
else {
mess.append(temp.substr(0, indk));
mess.append(killer);
mess.append(temp.substr(indk + 1, ind - 1));
mess.append(username);
mess.append(temp.substr(ind + 1));
}
return mess;
}

10
SQCSim-srv/server.h
View File

@ -1,6 +1,7 @@
#ifndef SERVER_H__
#define SERVER_H__
#include <cstdlib>
#include <fstream>
#include <vector>
#include <set>
@ -23,6 +24,9 @@ public:
int Init();
int Ready();
void Run();
void Cleanup();
void DeInit();
bool NewGameRequested() const;
private:
@ -36,19 +40,21 @@ private:
Buffer m_buf;
std::unordered_map<uint64_t, Connection*> m_players;
std::unordered_map<uint64_t, Player*> m_players;
std::unordered_map<uint64_t, Connection*> m_conns;
std::unordered_map<Timestamp, Chat> m_chatlog;
std::vector<uint64_t> m_ids;
GameInfo m_game;
World* m_world = nullptr;
const bool m_manual_setup = SRV_MANUAL_SETUP;
bool m_exit = true;
std::string LogTimestamp();
void Log(std::string str, bool is_error, bool is_fatal);
void buildIdList(size_t size);
uint64_t getUniqueId();
std::string getDeathMessage(std::string username, std::string killer) const;
};

4
SQCSim2021/SQCSim2021.vcxproj
View File

@ -91,7 +91,7 @@
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>true</WholeProgramOptimization>
<CharacterSet>Unicode</CharacterSet>
<PlatformToolset>v143</PlatformToolset>
<PlatformToolset>ClangCL</PlatformToolset>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
@ -196,7 +196,7 @@
<FloatingPointModel>Fast</FloatingPointModel>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>false</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>

2
SQCSim2021/audio.cpp
View File

@ -14,7 +14,7 @@ Audio::Audio(const char * music) {
m_engine->setRolloffFactor(2);
m_engine->setDefault3DSoundMinDistance(.1);
m_engine->setDefault3DSoundMaxDistance(1000);
m_music = m_engine->play2D(music, false, true, true, irrklang::ESM_STREAMING);
m_music = m_engine->play2D(music, true, true, true, irrklang::ESM_STREAMING);
}
Audio::~Audio() {

2
SQCSim2021/booster.cpp
View File

@ -1,4 +1,4 @@
#include "booster.h";
#include "booster.h"
void Booster::RenderBillboard(const Vector3f pos, TextureAtlas& textureAtlas, Shader& shader, Transformation tran)
{

2
SQCSim2021/cmake/CMakeLists.txt
View File

@ -28,6 +28,7 @@ include_directories(
add_library(SQCSim-common
"${SQCSIM_COMMON_DIR}boostinfo.cpp"
"${SQCSIM_COMMON_DIR}blockinfo.cpp"
"${SQCSIM_COMMON_DIR}bullet.cpp"
"${SQCSIM_COMMON_DIR}chunk.cpp"
@ -40,6 +41,7 @@ add_library(SQCSim-common
add_executable(SQCSim-client
"../audio.cpp"
"../booster.cpp"
"../connector.cpp"
"../engine.cpp"
"../mesh.cpp"

14
SQCSim2021/connector.cpp
View File

@ -65,20 +65,15 @@ int Connector::Connect(const char* srv_addr, std::string name) {
netprot::Buffer bf;
netprot::LoginInfo log;
strcpy(log.name, name.c_str());
strcpy(log.name, 32, name.c_str());
netprot::sendPack(m_sock_tcp, &log, &bf);
//using namespace std::chrono_literals;
//std::this_thread::sleep_for(100ms);
memset(bf.ptr, '\0', BUFFER_LENGTH);
bool ready = false;
int errors = 0;
std::vector<char*> lsPck;
while (!ready) {
lsPck = netprot::recvPacks(m_sock_tcp, &bf);
netprot::recvPacks(m_sock_udp, &bf, &lsPck);
for (auto& pck : lsPck) {
uint32_t bsize = bf.len - (pck - bf.ptr);
@ -97,7 +92,10 @@ int Connector::Connect(const char* srv_addr, std::string name) {
pl = new netprot::PlayerInfo();
if (!netprot::Deserialize(pl, pck, &bsize))
++errors;
else m_players[pl->id] = pl;
else {
m_players[pl->id] = pl;
std::cout << "A challenger appears! " << pl->name << std::endl;
}
break;
case TEAMINF:
// TODO: Faire dequoi avec TeamInfo si on fini par avoir des teams.

11
SQCSim2021/define.h
View File

@ -28,8 +28,17 @@
#define BASE_WIDTH 640
#define BASE_HEIGHT 480
#define ANIME_PATH_JUMP "./media/textures/AssetOtherPlayer/FinalPNGJumping/"
#define ANIME_PATH_STILL "./media/textures/AssetOtherPlayer/FinalPNGStanding/"
//1 = jump shoot sans anim, 2 = jump shoot avec anim
#define ANIM_PATH_JSHOOT1 "./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/"
#define ANIM_PATH_JSHOOT2 "./media/textures/AssetOtherPlayer/FinalPNGJumpingShooting/ShootingJump/"
//1 = shoot sans anim, 2 = shoot avec anim
#define ANIM_PATH_SSHOOT1 "./media/textures/AssetOtherPlayer/FinalPNGShooting/"
#define ANIM_PATH_SSHOOT2 "./media/textures/AssetOtherPlayer/FinalPNGShooting/Shooting/"
#define TEXTURE_PATH "./media/textures/"
#define SHADER_PATH "./media/shaders/"
#define AUDIO_PATH "./media/audio/"
@ -39,8 +48,8 @@
enum GameState {
MAIN_MENU,
SPLASH,
LOBBY,
OPTIONS,
QUIT,
PLAY,
PAUSE
};

918
SQCSim2021/engine.cpp
View File

File diff suppressed because it is too large Load Diff

56
SQCSim2021/engine.h
View File

@ -5,6 +5,7 @@
#include <chrono>
#include <cmath>
#include <unordered_map>
#include <set>
#include "../SQCSim-common/array2d.h"
#include "../SQCSim-common/blockinfo.h"
#include "../SQCSim-common/boostinfo.h"
@ -45,6 +46,7 @@ private:
int GetFps(float elapsedTime) const;
int GetCountdown(float elapsedTime);
int GetOptionsChoice();
bool StartMultiplayerGame();
bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps = true, bool stopOnError = true);
@ -61,13 +63,18 @@ private:
void DisplayInfo(float elapsedTime, BlockType bloc);
void DisplaySplashScreen();
void DisplayPauseMenu();
void DisplayMainMenu();
void DrawButtonBackgrounds(float centerX, float centerY, int iterations);
void DrawMainMenuButtons(float centerX, float centerY);
void DrawSingleMultiButtons(float centerX, float centerY);
void DisplayLobbyMenu(float elapsedTime);
void SetPlayerUsername(float elapsedTime);
void SetServerAddress(float elapsedTime);
void DisplayPauseMenu(float elapsedTime);
void DisplayOptionsMenu();
void DisplayAudioMenu(float centerX, float centerY);
void DisplayGraphicsMenu(float centerX, float centerY);
@ -76,25 +83,20 @@ private:
void DisplayBarPercentValue(float centerX, float centerY, float posX, float posY, float minVal, float maxVal, float value);
void DrawSlider(float centerX, float centerY, float value, float minVal, float maxVal, float bottomSideValue, float topSideValue);
void PrintText(float x, float y, const std::string& t, float charSizeMultiplier = 1.0f);
void ProcessNotificationQueue();
char SimulateKeyboard(unsigned char key);
void HandlePlayerInput(float elapsedTime);
Connector m_conn;
Audio m_audio = Audio(AUDIO_PATH "start.wav");
//udio m_menuaudio = Audio(AUDIO_PATH "menumusic.wav");
Audio m_audio = Audio(AUDIO_PATH "music01.wav");
irrklang::ISound* m_powpow, * m_scream;
irrklang::ISound* m_whoosh[MAX_BULLETS];
Bullet* m_bullets[MAX_BULLETS];
std::chrono::high_resolution_clock::time_point m_startTime;
std::unordered_map<uint64_t, Player*> m_players;
netprot::Buffer m_buf, m_bufout;
netprot::PlayerInfo m_pinfo;
RemotePlayer m_remotePlayer = RemotePlayer(netprot::PlayerInfo(), Vector3f(5.5f, CHUNK_SIZE_Y + 1.8f, 5.5f));
std::string m_messageNotification = "";
//Menu
Vector3f m_otherplayerpos = Vector3f(999, 999, 999);
World m_world = World();
Player m_player = Player(Vector3f(.5f, CHUNK_SIZE_Y + 1.8f, .5f));
@ -122,6 +124,7 @@ private:
Texture m_texturePovGun;
Texture m_textureSkybox;
Texture m_textureLobbyMenu;
Texture m_textureMainMenu;
Texture m_textureOptionsMenu;
Texture m_texturePauseMenu;
@ -131,9 +134,15 @@ private:
Texture m_textureFhd;
Texture m_textureQhd;
Texture m_textureUhd;
Texture m_textureLobbyServer;
Texture m_textureLobbyIdentify;
Texture m_textureCheck;
Texture m_textureChecked;
Texture m_texturePauseResume;
Texture m_texturePauseMainMenu;
Texture m_textureOptAudio;
Texture m_textureOptBack;
Texture m_textureOptGameplay;
@ -197,6 +206,16 @@ private:
bool m_selectedOptions = false;
bool m_selectedQuit = false;
std::string m_currentInputString;
std::string m_username;
std::string m_serverAddr;
char m_inputChar = 0;
bool m_invalidChar = false;
bool m_charChanged = false;
bool m_settingUsername = false;
bool m_settingServer = false;
bool m_multiReady = false;
bool m_key1 = false;
bool m_key2 = false;
bool m_keyK = false;
@ -205,7 +224,10 @@ private:
bool m_keyA = false;
bool m_keyS = false;
bool m_keyD = false;
bool m_keyEnter = false;
bool m_keySpace = false;
bool m_keyShift = false;
bool m_keyBackspace = false;
bool m_mouseL = false;
bool m_mouseR = false;
@ -217,6 +239,16 @@ private:
float m_mousemy = 0;
bool m_networkgame = false;
Connector m_conn;
std::deque<netprot::ChunkMod*> m_chunkmod_manifest;
std::chrono::high_resolution_clock::time_point m_startTime;
std::unordered_map<uint64_t, Player*> m_players;
netprot::Buffer m_buf, m_bufout;
netprot::ChunkMod* m_chunkmod = nullptr;
std::unordered_map<uint64_t, netprot::Sync> m_syncs;
std::string m_messageNotification = "";
};
#endif // ENGINE_H__

BIN
SQCSim2021/media/textures/menus/backgrounds/bgLobby.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 505 KiB

BIN
SQCSim2021/media/textures/menus/backgrounds/bgPause.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 562 KiB

After

Width:  |  Height:  |  Size: 596 KiB

BIN
SQCSim2021/media/textures/menus/buttons/pause/pauseMainMenu.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.5 KiB

BIN
SQCSim2021/media/textures/menus/buttons/pause/pauseResume.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 6.8 KiB

BIN
SQCSim2021/media/textures/menus/labels/labelIdentify.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 17 KiB

BIN
SQCSim2021/media/textures/menus/labels/labelServer.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 11 KiB

2
SQCSim2021/openglcontext.cpp
View File

@ -16,8 +16,8 @@ bool OpenglContext::Start(const std::string& title, int width, int height, bool
m_fullscreen = fullscreen;
InitWindow(width, height);
Init();
LoadResource();
Init();
sf::Clock clock;

251
SQCSim2021/remoteplayer.cpp
View File

@ -10,14 +10,10 @@
RemotePlayer::RemotePlayer(netprot::PlayerInfo pinfo) : m_pinfo(pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(Vector3f(0, 0, 0)){
LoadTexture(m_texture_front, TEXTURE_PATH "AssetOtherPlayer/FinalPNGStanding/BlueFrontRight.png", false, false);
}
RemotePlayer::RemotePlayer(netprot::PlayerInfo pinfo, const Vector3f& pos) : m_pinfo(pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous(), m_texture_front(), Player(pos) {
LoadTexture(m_texture_front, TEXTURE_PATH "AssetOtherPlayer/FinalPNGStanding/BlueFrontRight.png", false, false);
}
@ -33,6 +29,11 @@ void RemotePlayer::Init()
void RemotePlayer::Feed(const netprot::Output out) {
m_position = Vector3f(out.position);
m_direction = Vector3f(out.direction);
current.states = out.states;
//current.position = out.position;
//current.direction = out.direction;
//current.states = out.states;
@ -75,35 +76,232 @@ void RemotePlayer::Feed(const netprot::Output out) {
//previous.position = current.position;
//previous.states = current.states;
//previous.id = current.id;
//m_direction = current.direction;
//m_position = current.position;
}
void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tran, float elapsedTime)
void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tran, float elapsedTime, Player& camera)
{
float x = GetPosition().x;
float y = GetPosition().y;
float z = GetPosition().z;
float width = 1.f;
float height = 1.7f;
Vector3f DiffCam = GetPosition() - camera.GetPosition();
Vector3f UpCam = Vector3f(0.f, 1.f, 0.f);
Vector3f CrossA = DiffCam.Cross(UpCam);
Vector3f CrossB = DiffCam.Cross(CrossA);
CrossA.Normalize();
CrossB.Normalize();
Vector3f playerPosition = GetPosition() + Vector3f(0.f, -.75f, 0.f);
Vector3f v2 = (playerPosition + CrossA * 0.5 * width + CrossB * 0.5 * height);
Vector3f v1 = (playerPosition - CrossA * 0.5 * width + CrossB * 0.5 * height);
Vector3f v3 = (playerPosition + CrossA * 0.5 * width - CrossB * 0.5 * height);
Vector3f v4 = (playerPosition - CrossA * 0.5 * width - CrossB * 0.5 * height);
Vector3f angleRemote = GetDirection();
Vector3f angleCam = (v1 - v2).Cross(v3 - v2);
angleCam.y = 0;
angleRemote.y = 0;
angleCam.Normalize();
angleRemote.Normalize();
float angle = angleRemote.Dot(angleCam);
int index = 0;
angle = -angle;
Vector3f side = angleRemote.Cross(angleCam);
static float time = 0.f;
static bool Shooting = false;
bool isLeft = side.y > 0;
time += elapsedTime;
if (time >= 200)
{
time -= 200;
if (!current.states.shooting)
Shooting = false;
else
Shooting = !Shooting;
}
if (angle >= 0.75) //Face - side positif
{
if(current.states.shooting){
if (Shooting)
index = 17;
else
index = 9;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 41;
else
index = 33;
}
else if (current.states.jumping)
index = 25;
else if (current.states.running && current.states.still)
index = 0;
}
else if (angle >= 0.25 && isLeft) //Frontleft
{
if (current.states.shooting) {
if (Shooting)
index = 18;
else
index = 10;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 42;
else
index = 34;
}
else if (current.states.jumping )
index = 26;
else if (current.states.running && current.states.still)
index = 1;
}
else if (angle >= -0.25 && isLeft) //ProfileLeft
{
if (current.states.shooting) {
if (Shooting)
index = 20;
else
index = 12;
}
else if (current.states.jumpshot ) {
if (Shooting)
index = 44;
else
index = 36;
}
else if (current.states.jumping )
index = 28;
else if (current.states.running && current.states.still)
index = 3;
}
else if (angle >= -0.75 && isLeft) //BackLeft
{
if (current.states.shooting) {
if (Shooting)
index = 22;
else
index = 14;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 46;
else
index = 38;
}
else if (current.states.jumping)
index = 30;
else if (current.states.running && current.states.still)
index = 5;
}
else if (angle < -0.75) //Dos - side négatif
{
if (current.states.shooting) {
if (Shooting)
index = 24;
else
index = 16;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 48;
else
index = 40;
}
else if (current.states.jumping )
index = 32;
else if (current.states.running && current.states.still)
index = 7;
}
else if (angle >= 0.25 && !isLeft) //FrontRight
{
if (current.states.shooting) {
if (Shooting)
index = 19;
else
index = 11;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 43;
else
index = 35;
}
else if (current.states.jumping)
index = 27;
else if (current.states.running && current.states.still)
index = 2;
}
else if (angle >= -0.25 && !isLeft) //ProfileRight
{
if (current.states.shooting) {
if (Shooting)
index = 21;
else
index = 13;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 45;
else
index = 37;
}
else if (current.states.jumping)
index = 29;
else if (current.states.running && current.states.still)
index = 4;
}
else if (angle >= -0.75 && !isLeft) //BackRight
{
if (current.states.shooting) {
if (Shooting)
index = 23;
else
index = 15;
}
else if (current.states.jumpshot) {
if (Shooting)
index = 47;
else
index = 39;
}
else if (current.states.jumping)
index = 31;
else if (current.states.running && current.states.still)
index = 6;
}
//Matrix4 mat4 = tran.GetMatrix();
//mat4 VP = pMatrix * vMatrix;
//Vector3f CameraRight = Vector3f(mat4.Get11(), mat4.Get21(), mat4.Get31());
//Vector3f CameraUp = Vector3f(mat4.Get12(), mat4.Get22(), mat4.Get32());
//Vector3f v1 = (m_position + CameraRight * 0.5 * width + CameraUp * -0.5 * width);
//Vector3f v2 = (m_position + CameraRight * 0.5 * width + CameraUp * 0.5 * width);
//Vector3f v4 = (m_position + CameraRight * -0.5 * width + CameraUp * -0.5 * width);
//Vector3f v3 = (m_position + CameraRight * -0.5 * width + CameraUp * 0.5 * width);
//tran.ApplyTranslation(m_position);
float u, v, w, h;
//glDisable(GL_DEPTH_TEST);
shader.Use();
atlas.Bind();
atlas.TextureIndexToCoord(0, u, v, w, h);
//glLoadIdentity();
atlas.TextureIndexToCoord(index, u, v, w, h);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@ -111,20 +309,19 @@ void RemotePlayer::Render(TextureAtlas& atlas, Shader& shader, Transformation tr
glLoadMatrixf(tran.GetMatrix().GetInternalValues());
glBegin(GL_QUADS);
glTexCoord2f(u, v); glVertex3f(x - width/2., y - height, z); //glVertex3f(v4.x, v4.y, v4.z);//glVertex3f(0, 50, 0);
glTexCoord2f(u + w, v); glVertex3f(x+width/2., y - height, z); //glVertex3f(v3.x, v3.y, v3.z); //glVertex3f(50,50, 0);
glTexCoord2f(u + w, v + h); glVertex3f(x+width/2., y, z); //glVertex3f(v2.x, v2.y, v2.z); //glVertex3f(50, 0, 0);
glTexCoord2f(u, v + h); glVertex3f(x-width/2., y, z); //glVertex3f(v1.x, v1.y, v1.z);// glVertex3f(0, 0, 0);
glEnd();
glTexCoord2f(u, v); glVertex3f(v1.x, v1.y, v1.z);
glTexCoord2f(u + w, v); glVertex3f(v2.x, v2.y, v2.z);
glTexCoord2f(u + w, v + h); glVertex3f(v3.x, v3.y, v3.z);
glTexCoord2f(u, v + h); glVertex3f(v4.x, v4.y, v4.z);
glEnd();
glBlendFunc(GL_CONSTANT_COLOR, GL_ONE_MINUS_CONSTANT_COLOR);
glBlendEquation(GL_FUNC_SUBTRACT);
glDisable(GL_BLEND);
shader.Disable();
//tran.ApplyTranslation(-m_position);
//glEnable(GL_DEPTH_TEST);
}
bool RemotePlayer::LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps, bool stopOnError)

2
SQCSim2021/remoteplayer.h
View File

@ -21,7 +21,7 @@ public:
void Init();
void Feed(const netprot::Output out);
void Render(TextureAtlas& atlas, Shader& shader, Transformation tran, float elapsedTime);
void Render(TextureAtlas& atlas, Shader& shader, Transformation tran, float elapsedTime, Player& camera);
bool LoadTexture(Texture& texture, const std::string& filename, bool useMipmaps, bool stopOnError);
void SetPosition(Vector3f pos) { m_position = pos; }