diff --git a/.gitignore b/.gitignore index f15149d..8ffde58 100644 --- a/.gitignore +++ b/.gitignore @@ -378,3 +378,5 @@ FodyWeavers.xsd /SQCSim2021/cmake/* !/SQCSim2021/cmake/CMakeLists.txt /SQCSim2021/SQCSim-client +SQCSim2021/SQCSim2021.vcxproj.filters +SQCSim2021/SQCSim2021.vcxproj diff --git a/SQCSim-common/SQCSim-common.vcxproj b/SQCSim-common/SQCSim-common.vcxproj index 991cd1d..4cebfaf 100644 --- a/SQCSim-common/SQCSim-common.vcxproj +++ b/SQCSim-common/SQCSim-common.vcxproj @@ -76,6 +76,7 @@ true WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console @@ -90,6 +91,7 @@ true WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console @@ -104,6 +106,7 @@ true _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console @@ -118,7 +121,7 @@ true NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true - stdcpp17 + stdcpp20 Console diff --git a/SQCSim-common/define.h b/SQCSim-common/define.h index f65bc2b..05d90da 100644 --- a/SQCSim-common/define.h +++ b/SQCSim-common/define.h @@ -4,8 +4,10 @@ #include #include -#define SRV_PORT 1025 -#define CLI_PORT 1026 +#define SRV_PORT 10000 +#define CLI_PORT 10001 + +#define BUFFER_LENGTH 150 #define CHUNK_SIZE_X 4 #define CHUNK_SIZE_Y 64 @@ -29,6 +31,8 @@ #define TEXTURE_SIZE 512 #define MAX_BULLETS 512 +#define BULLET_TIME .1 + typedef uint8_t BlockType; enum BLOCK_TYPE { BTYPE_AIR, BTYPE_DIRT, BTYPE_GRASS, BTYPE_METAL, BTYPE_ICE, BTYPE_LAST }; typedef uint64_t Timestamp; @@ -42,6 +46,11 @@ typedef uint64_t Timestamp; #include #include +#define flag_t u_long +#define addrlen_t int +#define ioctl ioctlsocket +#define SOCK_NONBLOCK FIONBIO +#define strcpy strcpy_s #define popen _popen #define pclose _pclose @@ -51,10 +60,13 @@ typedef uint64_t Timestamp; #include #include #include +#include #include #include #include +#define flag_t unsigned int +#define addrlen_t unsigned int #define SOCKET int #define INVALID_SOCKET -1 #define closesocket close diff --git a/SQCSim-common/netprotocol.cpp b/SQCSim-common/netprotocol.cpp index d4edca2..d31d425 100644 --- a/SQCSim-common/netprotocol.cpp +++ b/SQCSim-common/netprotocol.cpp @@ -1,29 +1,29 @@ #include "netprotocol.h" void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::INPUT; + *buf[0] = (char)netprot::PACKET_TYPE::INPUT; uint64_t time = in->timestamp; - uint8_t time8[sizeof(uint64_t)] = {(time >> 56) & 0xFF, - (time >> 48) & 0xFF, - (time >> 40) & 0xFF, - (time >> 32) & 0xFF, - (time >> 24) & 0xFF, - (time >> 16) & 0xFF, - (time >> 8 ) & 0xFF, - time & 0xFF}; + uint8_t time8[sizeof(uint64_t)] = {(uint8_t)((time >> 56) & 0xFF), + (uint8_t)((time >> 48) & 0xFF), + (uint8_t)((time >> 40) & 0xFF), + (uint8_t)((time >> 32) & 0xFF), + (uint8_t)((time >> 24) & 0xFF), + (uint8_t)((time >> 16) & 0xFF), + (uint8_t)((time >> 8 ) & 0xFF), + (uint8_t)(time & 0xFF)}; memcpy(*buf + 1, time8, sizeof(uint64_t)); uint64_t sid = in->sid; - uint8_t sid8[sizeof(uint64_t)] = {(sid >> 56) & 0xFF, - (sid >> 48) & 0xFF, - (sid >> 40) & 0xFF, - (sid >> 32) & 0xFF, - (sid >> 24) & 0xFF, - (sid >> 16) & 0xFF, - (sid >> 8 ) & 0xFF, - sid & 0xFF}; + uint8_t sid8[sizeof(uint64_t)] = {(uint8_t)((sid >> 56) & 0xFF), + (uint8_t)((sid >> 48) & 0xFF), + (uint8_t)((sid >> 40) & 0xFF), + (uint8_t)((sid >> 32) & 0xFF), + (uint8_t)((sid >> 24) & 0xFF), + (uint8_t)((sid >> 16) & 0xFF), + (uint8_t)((sid >> 8 ) & 0xFF), + (uint8_t)( sid & 0xFF)}; memcpy(*buf + sizeof(uint64_t) + 1, sid8, sizeof(uint64_t)); @@ -37,54 +37,140 @@ void netprot::Serialize(Input* in, char* buf[], uint32_t* buflen) { keys.shoot & 0b00000100 | keys.block & 0b00000010 ; - memcpy(*buf + sizeof(uint64_t) + 2, &keys8, sizeof(uint8_t)); + memcpy(*buf + sizeof(uint64_t) * 2 + 1, &keys8, sizeof(uint8_t)); uint32_t vec[3]; - memcpy(vec, &in->direction, sizeof(Vector3f)); // Pour dénaturer les floats. + memcpy(vec, &in->direction, sizeof(Vector3f)); // Pour d�naturer les floats. uint8_t vec8[3 * sizeof(uint32_t)] = { - (vec[0] >> 24) & 0xFF, - (vec[0] >> 16) & 0xFF, - (vec[0] >> 8) & 0xFF, - vec[0] & 0xFF, - (vec[1] >> 24) & 0xFF, - (vec[1] >> 16) & 0xFF, - (vec[1] >> 8) & 0xFF, - vec[1] & 0xFF, - (vec[2] >> 24) & 0xFF, - (vec[2] >> 16) & 0xFF, - (vec[2] >> 8) & 0xFF, - vec[2] & 0xFF}; + (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 + sizeof(uint64_t) + 3, vec8, sizeof(uint32_t) * 3); + memcpy(*buf + sizeof(uint64_t) * 2 + 2, vec8, sizeof(uint32_t) * 3); - *buflen = sizeof(uint64_t) + 3 + sizeof(uint32_t) * 3; + *buflen = sizeof(uint64_t) * 2 + 2 + sizeof(uint32_t) * 3; } void netprot::Serialize(Output* out, char* buf[], uint32_t* buflen) { + *buf[0] = (char)netprot::PACKET_TYPE::OUTPUT; + uint64_t time = out->timestamp; + uint8_t time8[sizeof(uint64_t)] = { (uint8_t)((time >> 56) & 0xFF), + (uint8_t)((time >> 48) & 0xFF), + (uint8_t)((time >> 40) & 0xFF), + (uint8_t)((time >> 32) & 0xFF), + (uint8_t)((time >> 24) & 0xFF), + (uint8_t)((time >> 16) & 0xFF), + (uint8_t)((time >> 8) & 0xFF), + (uint8_t)(time & 0xFF) }; + + memcpy(*buf + 1, time8, sizeof(uint64_t)); + + uint64_t sid = out->id; + uint8_t sid8[sizeof(uint64_t)] = { (uint8_t)((sid >> 56) & 0xFF), + (uint8_t)((sid >> 48) & 0xFF), + (uint8_t)((sid >> 40) & 0xFF), + (uint8_t)((sid >> 32) & 0xFF), + (uint8_t)((sid >> 24) & 0xFF), + (uint8_t)((sid >> 16) & 0xFF), + (uint8_t)((sid >> 8) & 0xFF), + (uint8_t)(sid & 0xFF) }; + + memcpy(*buf + sizeof(uint64_t) + 1, sid8, sizeof(uint64_t)); + + // TODO: Finir ca. } void netprot::Serialize(Sync* sync, char* buf[], uint32_t* buflen) { + *buf[0] = (char)netprot::PACKET_TYPE::SYNC; + uint64_t time = sync->timestamp; + uint8_t stamp8[sizeof(uint64_t)] = { (uint8_t)((time >> 56) & 0xFF), + (uint8_t)((time >> 48) & 0xFF), + (uint8_t)((time >> 40) & 0xFF), + (uint8_t)((time >> 32) & 0xFF), + (uint8_t)((time >> 24) & 0xFF), + (uint8_t)((time >> 16) & 0xFF), + (uint8_t)((time >> 8) & 0xFF), + (uint8_t)(time & 0xFF) }; + + memcpy(*buf + 1, stamp8, sizeof(uint64_t)); + uint64_t sid = sync->sid; + uint8_t sid8[sizeof(uint64_t)] = { (uint8_t)((sid >> 56) & 0xFF), + (uint8_t)((sid >> 48) & 0xFF), + (uint8_t)((sid >> 40) & 0xFF), + (uint8_t)((sid >> 32) & 0xFF), + (uint8_t)((sid >> 24) & 0xFF), + (uint8_t)((sid >> 16) & 0xFF), + (uint8_t)((sid >> 8) & 0xFF), + (uint8_t)(sid & 0xFF) }; + + memcpy(*buf + sizeof(uint64_t) + 1, sid8, sizeof(uint64_t)); + + uint32_t timer = sync->timer; + uint8_t time8[sizeof(uint32_t)] = {(uint8_t)((timer >> 24) & 0xFF), + (uint8_t)((timer >> 16) & 0xFF), + (uint8_t)((timer >> 8) & 0xFF), + (uint8_t)(timer & 0xFF) }; + + memcpy(*buf + sizeof(uint64_t) * 2 + 1, time8, sizeof(uint32_t)); + + uint16_t ammo = sync->ammo; + uint8_t ammo8[sizeof(uint16_t)] = { (uint8_t)((ammo >> 8) & 0xFF), + (uint8_t)(ammo & 0xFF) }; + + 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. + + 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 + sizeof(uint64_t) * 2 + sizeof(uint32_t) + sizeof(uint16_t) + 2, vec8, sizeof(uint32_t) * 3); + + *buflen = sizeof(uint64_t) * 2 + sizeof(uint32_t) * 4 + sizeof(uint16_t) + 2; } void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::TEAMINF; + *buf[0] = (char)netprot::PACKET_TYPE::TEAMINF; size_t namesize = std::strlen(tinfo->name) + 1; memcpy(*buf + 1, &tinfo->name, namesize); uint64_t tid = tinfo->id; uint8_t tid8[sizeof(uint64_t)] = { - (tid >> 56) & 0xFF, - (tid >> 48) & 0xFF, - (tid >> 40) & 0xFF, - (tid >> 32) & 0xFF, - (tid >> 24) & 0xFF, - (tid >> 16) & 0xFF, - (tid >> 8) & 0xFF, - tid & 0xFF + (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 + namesize + 2, tid8, sizeof(uint64_t)); @@ -93,35 +179,35 @@ void netprot::Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen) { } void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::LOGINF; + *buf[0] = (char)netprot::PACKET_TYPE::LOGINF; size_t namesize = std::strlen(linfo->name) + 1; memcpy(*buf + 1, &linfo->name, namesize); uint64_t sid = linfo->sid; uint8_t sid8[sizeof(uint64_t)] = { - (sid >> 56) & 0xFF, - (sid >> 48) & 0xFF, - (sid >> 40) & 0xFF, - (sid >> 32) & 0xFF, - (sid >> 24) & 0xFF, - (sid >> 16) & 0xFF, - (sid >> 8) & 0xFF, - sid & 0xFF + (uint8_t)((sid >> 56) & 0xFF), + (uint8_t)((sid >> 48) & 0xFF), + (uint8_t)((sid >> 40) & 0xFF), + (uint8_t)((sid >> 32) & 0xFF), + (uint8_t)((sid >> 24) & 0xFF), + (uint8_t)((sid >> 16) & 0xFF), + (uint8_t)((sid >> 8) & 0xFF), + (uint8_t)(sid & 0xFF) }; memcpy(*buf + namesize + 2, sid8, sizeof(uint64_t)); uint64_t tid = linfo->tid; uint8_t tid8[sizeof(uint64_t)] = { - (tid >> 56) & 0xFF, - (tid >> 48) & 0xFF, - (tid >> 40) & 0xFF, - (tid >> 32) & 0xFF, - (tid >> 24) & 0xFF, - (tid >> 16) & 0xFF, - (tid >> 8) & 0xFF, - tid & 0xFF + (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 + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t)); @@ -130,35 +216,35 @@ void netprot::Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen) { } void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::PLAYINF; + *buf[0] = (char)netprot::PACKET_TYPE::PLAYINF; size_t namesize = std::strlen(pinfo->name) + 1; memcpy(*buf + 1, &pinfo->name, namesize); uint64_t id = pinfo->id; uint8_t id8[sizeof(uint64_t)] = { - (id >> 56) & 0xFF, - (id >> 48) & 0xFF, - (id >> 40) & 0xFF, - (id >> 32) & 0xFF, - (id >> 24) & 0xFF, - (id >> 16) & 0xFF, - (id >> 8) & 0xFF, - id & 0xFF + (uint8_t)((id >> 56) & 0xFF), + (uint8_t)((id >> 48) & 0xFF), + (uint8_t)((id >> 40) & 0xFF), + (uint8_t)((id >> 32) & 0xFF), + (uint8_t)((id >> 24) & 0xFF), + (uint8_t)((id >> 16) & 0xFF), + (uint8_t)((id >> 8) & 0xFF), + (uint8_t)(id & 0xFF) }; memcpy(*buf + namesize + 2, id8, sizeof(uint64_t)); uint64_t tid = pinfo->tid; uint8_t tid8[sizeof(uint64_t)] = { - (tid >> 56) & 0xFF, - (tid >> 48) & 0xFF, - (tid >> 40) & 0xFF, - (tid >> 32) & 0xFF, - (tid >> 24) & 0xFF, - (tid >> 16) & 0xFF, - (tid >> 8) & 0xFF, - tid & 0xFF + (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 + namesize + 2 + sizeof(uint64_t), tid8, sizeof(uint64_t)); @@ -167,46 +253,46 @@ void netprot::Serialize(PlayerInfo* pinfo, char* buf[], uint32_t* buflen) { } void netprot::Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::GAMEINFO; + *buf[0] = (char)netprot::PACKET_TYPE::GAMEINFO; uint64_t game = ginfo->seed; uint8_t seed8[sizeof(uint64_t)] = { - (game >> 56) & 0xFF, - (game >> 48) & 0xFF, - (game >> 40) & 0xFF, - (game >> 32) & 0xFF, - (game >> 24) & 0xFF, - (game >> 16) & 0xFF, - (game >> 8) & 0xFF, - game & 0xFF + (uint8_t)((game >> 56) & 0xFF), + (uint8_t)((game >> 48) & 0xFF), + (uint8_t)((game >> 40) & 0xFF), + (uint8_t)((game >> 32) & 0xFF), + (uint8_t)((game >> 24) & 0xFF), + (uint8_t)((game >> 16) & 0xFF), + (uint8_t)((game >> 8) & 0xFF), + (uint8_t)(game & 0xFF) }; memcpy(*buf + 1, seed8, sizeof(uint64_t)); game = ginfo->countdown; uint8_t count8[sizeof(uint64_t)] = { - (game >> 56) & 0xFF, - (game >> 48) & 0xFF, - (game >> 40) & 0xFF, - (game >> 32) & 0xFF, - (game >> 24) & 0xFF, - (game >> 16) & 0xFF, - (game >> 8) & 0xFF, - game & 0xFF + (uint8_t)((game >> 56) & 0xFF), + (uint8_t)((game >> 48) & 0xFF), + (uint8_t)((game >> 40) & 0xFF), + (uint8_t)((game >> 32) & 0xFF), + (uint8_t)((game >> 24) & 0xFF), + (uint8_t)((game >> 16) & 0xFF), + (uint8_t)((game >> 8) & 0xFF), + (uint8_t)(game & 0xFF) }; memcpy(*buf + sizeof(uint64_t) + 1, count8, sizeof(uint64_t)); game = ginfo->countdown; uint8_t gtype8[sizeof(uint64_t)] = { - (game >> 56) & 0xFF, - (game >> 48) & 0xFF, - (game >> 40) & 0xFF, - (game >> 32) & 0xFF, - (game >> 24) & 0xFF, - (game >> 16) & 0xFF, - (game >> 8) & 0xFF, - game & 0xFF + (uint8_t)((game >> 56) & 0xFF), + (uint8_t)((game >> 48) & 0xFF), + (uint8_t)((game >> 40) & 0xFF), + (uint8_t)((game >> 32) & 0xFF), + (uint8_t)((game >> 24) & 0xFF), + (uint8_t)((game >> 16) & 0xFF), + (uint8_t)((game >> 8) & 0xFF), + (uint8_t)(game & 0xFF) }; memcpy(*buf + sizeof(uint64_t) + 1, gtype8, sizeof(uint64_t)); @@ -215,46 +301,46 @@ void netprot::Serialize(GameInfo* ginfo, char* buf[], uint32_t* buflen) { } void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::CHAT; + *buf[0] = (char)netprot::PACKET_TYPE::CHAT; uint64_t src = chat->src_id; uint8_t src8[sizeof(uint64_t)] = { - (src >> 56) & 0xFF, - (src >> 48) & 0xFF, - (src >> 40) & 0xFF, - (src >> 32) & 0xFF, - (src >> 24) & 0xFF, - (src >> 16) & 0xFF, - (src >> 8) & 0xFF, - src & 0xFF + (uint8_t)((src >> 56) & 0xFF), + (uint8_t)((src >> 48) & 0xFF), + (uint8_t)((src >> 40) & 0xFF), + (uint8_t)((src >> 32) & 0xFF), + (uint8_t)((src >> 24) & 0xFF), + (uint8_t)((src >> 16) & 0xFF), + (uint8_t)((src >> 8) & 0xFF), + (uint8_t)(src & 0xFF) }; memcpy(*buf + 1, src8, sizeof(uint64_t)); uint64_t dst = chat->dest_id; uint8_t dst8[sizeof(uint64_t)] = { - (dst >> 56) & 0xFF, - (dst >> 48) & 0xFF, - (dst >> 40) & 0xFF, - (dst >> 32) & 0xFF, - (dst >> 24) & 0xFF, - (dst >> 16) & 0xFF, - (dst >> 8) & 0xFF, - dst & 0xFF + (uint8_t)((dst >> 56) & 0xFF), + (uint8_t)((dst >> 48) & 0xFF), + (uint8_t)((dst >> 40) & 0xFF), + (uint8_t)((dst >> 32) & 0xFF), + (uint8_t)((dst >> 24) & 0xFF), + (uint8_t)((dst >> 16) & 0xFF), + (uint8_t)((dst >> 8) & 0xFF), + (uint8_t)(dst & 0xFF) }; memcpy(*buf + 1 + sizeof(uint64_t), dst8, sizeof(uint64_t)); uint64_t dstteam = chat->dest_id; uint8_t dstt8[sizeof(uint64_t)] = { - (dstteam >> 56) & 0xFF, - (dstteam >> 48) & 0xFF, - (dstteam >> 40) & 0xFF, - (dstteam >> 32) & 0xFF, - (dstteam >> 24) & 0xFF, - (dstteam >> 16) & 0xFF, - (dstteam >> 8) & 0xFF, - dstteam & 0xFF + (uint8_t)((dstteam >> 56) & 0xFF), + (uint8_t)((dstteam >> 48) & 0xFF), + (uint8_t)((dstteam >> 40) & 0xFF), + (uint8_t)((dstteam >> 32) & 0xFF), + (uint8_t)((dstteam >> 24) & 0xFF), + (uint8_t)((dstteam >> 16) & 0xFF), + (uint8_t)((dstteam >> 8) & 0xFF), + (uint8_t)(dstteam & 0xFF) }; memcpy(*buf + 1 + sizeof(uint64_t) * 2, dstt8, sizeof(uint64_t)); @@ -267,7 +353,7 @@ void netprot::Serialize(Chat* chat, char* buf[], uint32_t* buflen) { } void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) { - *buf[0] = netprot::PACKET_TYPE::ERRLOG; + *buf[0] = (char)netprot::PACKET_TYPE::ERRLOG; size_t messize = std::strlen(errlog->mess) + 1; @@ -281,7 +367,61 @@ void netprot::Serialize(ErrorLog* errlog, char* buf[], uint32_t* buflen) { bool netprot::Deserialize(Input* in, char* buf, const uint32_t buflen) { - return false; + if (buflen <= sizeof(Input)) + return false; + + uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 }; + memcpy(diff, &buf[1], sizeof(uint64_t)); + in->timestamp = + (uint64_t)diff[0] << 56 | + (uint64_t)diff[1] << 48 | + (uint64_t)diff[2] << 40 | + (uint64_t)diff[3] << 32 | + (uint64_t)diff[4] << 24 | + (uint64_t)diff[5] << 16 | + (uint64_t)diff[6] << 8 | + (uint64_t)diff[7]; + + memcpy(diff, &buf[1 + sizeof(uint64_t)], sizeof(uint64_t)); + in->sid = + (uint64_t)diff[0] << 56 | + (uint64_t)diff[1] << 48 | + (uint64_t)diff[2] << 40 | + (uint64_t)diff[3] << 32 | + (uint64_t)diff[4] << 24 | + (uint64_t)diff[5] << 16 | + (uint64_t)diff[6] << 8 | + (uint64_t)diff[7]; + + uint8_t keys = 0; + memcpy(&keys, &buf[1 + sizeof(uint64_t) * 2], sizeof(uint8_t)); + in->keys.forward = keys & 0b10000000; + in->keys.backward = keys & 0b01000000; + in->keys.left = keys & 0b00100000; + in->keys.right = keys & 0b00010000; + in->keys.jump = keys & 0b00001000; + in->keys.shoot = keys & 0b00000100; + in->keys.block = keys & 0b00000010; + + 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); + 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(&in->direction, vec, sizeof(uint32_t) * 3); + + return true; } bool netprot::Deserialize(Output* out, char* buf, const uint32_t buflen) { @@ -289,7 +429,65 @@ bool netprot::Deserialize(Output* out, char* buf, const uint32_t buflen) { } bool netprot::Deserialize(Sync* sync, char* buf, const uint32_t buflen) { - return false; + if (buflen <= sizeof(Sync)) + return false; + + uint8_t diff[sizeof(uint64_t)] = { 0,0,0,0,0,0,0,0 }; + memcpy(diff, &buf[1], sizeof(uint64_t)); + sync->timestamp = + (uint64_t)diff[0] << 56 | + (uint64_t)diff[1] << 48 | + (uint64_t)diff[2] << 40 | + (uint64_t)diff[3] << 32 | + (uint64_t)diff[4] << 24 | + (uint64_t)diff[5] << 16 | + (uint64_t)diff[6] << 8 | + (uint64_t)diff[7]; + + memcpy(diff, &buf[1 + sizeof(uint64_t)], sizeof(uint64_t)); + sync->sid = + (uint64_t)diff[0] << 56 | + (uint64_t)diff[1] << 48 | + (uint64_t)diff[2] << 40 | + (uint64_t)diff[3] << 32 | + (uint64_t)diff[4] << 24 | + (uint64_t)diff[5] << 16 | + (uint64_t)diff[6] << 8 | + (uint64_t)diff[7]; + + memcpy(diff, &buf[1 + sizeof(uint64_t) * 2], sizeof(uint32_t)); + sync->timer = + (uint32_t)diff[0] << 24 | + (uint32_t)diff[1] << 16 | + (uint32_t)diff[2] << 8 | + (uint32_t)diff[3]; + + memcpy(diff, &buf[1 + sizeof(uint64_t) * 2 + sizeof(uint32_t)], sizeof(uint16_t)); + sync->ammo = + (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); + 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(&sync->position, vec, sizeof(uint32_t) * 3); + + return true; } bool netprot::Deserialize(TeamInfo* tinfo, char* buf, const uint32_t buflen) { @@ -497,10 +695,246 @@ bool netprot::Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen) { return true; } -netprot::PacketType netprot::getType(char* buf, const uint32_t buflen) { +netprot::PACKET_TYPE netprot::getType(char* buf, const uint32_t buflen) { if (buflen < 1 || - buf[0] >= netprot::PACKET_TYPE::LAST_PACK || - buf[0] <= netprot::PACKET_TYPE::ERR) + buf[0] >= (char)netprot::PACKET_TYPE::LAST_PACK || + buf[0] <= (char)netprot::PACKET_TYPE::ERR) return netprot::PACKET_TYPE::ERR; - return buf[0]; + return (netprot::PACKET_TYPE)buf[0]; +} + +netprot::Packet netprot::getPack(char* buf, uint32_t buflen) { + Packet pck = { nullptr, PACKET_TYPE::ERR }; + Input* in = nullptr; + Output* out = nullptr; + Sync* sync = nullptr; + Chat* chat = nullptr; + GameInfo* ginfo = nullptr; + ErrorLog* errlog = nullptr; + LoginInfo* loginf = nullptr; + + switch (getType(buf, buflen)) { + case PACKET_TYPE::INPUT: + in = new Input(); + if (netprot::Deserialize(in, buf, buflen)) { + pck.type = PACKET_TYPE::INPUT; + pck.ptr = (void*)in; + } + break; + case PACKET_TYPE::OUTPUT: + out = new Output(); + if (netprot::Deserialize(out, buf, buflen)) { + pck.type = PACKET_TYPE::OUTPUT; + pck.ptr = (void*)out; + } + break; + case PACKET_TYPE::SYNC: + sync = new Sync(); + if (netprot::Deserialize(sync, buf, buflen)) { + pck.type = PACKET_TYPE::SYNC; + pck.ptr = (void*)sync; + } + break; + case PACKET_TYPE::CHAT: + chat = new Chat(); + if (netprot::Deserialize(chat, buf, buflen)) { + pck.type = PACKET_TYPE::CHAT; + pck.ptr = (void*)chat; + } + break; + case PACKET_TYPE::GAMEINFO: + ginfo = new GameInfo(); + if (netprot::Deserialize(ginfo, buf, buflen)) { + pck.type = PACKET_TYPE::GAMEINFO; + pck.ptr = (void*)ginfo; + } + break; + case PACKET_TYPE::ERRLOG: + errlog = new ErrorLog(); + if (netprot::Deserialize(errlog, buf, buflen)) { + pck.type = PACKET_TYPE::ERRLOG; + pck.ptr = (void*)errlog; + } + break; + case PACKET_TYPE::LOGINF: + loginf = new LoginInfo(); + if (netprot::Deserialize(loginf, buf, buflen)) { + pck.type = PACKET_TYPE::LOGINF; + pck.ptr = (void*)loginf; + } + break; + default: + break; + } + return pck; +} + +netprot::Packet netprot::getPack(netprot::Buffer* buf) { + return netprot::getPack(buf->ptr, buf->len); +} + +bool netprot::emptyPack(netprot::Packet pck) { + switch (pck.type) { + case PACKET_TYPE::INPUT: + delete (Input*)pck.ptr; + return true; + case PACKET_TYPE::OUTPUT: + delete (Output*)pck.ptr; + return true; + case PACKET_TYPE::SYNC: + delete (Sync*)pck.ptr; + return true; + case PACKET_TYPE::CHAT: + delete (Chat*)pck.ptr; + return true; + case PACKET_TYPE::GAMEINFO: + delete (GameInfo*)pck.ptr; + return true; + case PACKET_TYPE::ERRLOG: + delete (ErrorLog*)pck.ptr; + return true; + case PACKET_TYPE::LOGINF: + delete (LoginInfo*)pck.ptr; + return true; + default: + return false; + } +} + +netprot::Packet netprot::makePack(void* ptr, PACKET_TYPE type) { + Packet pck; + pck.ptr = ptr; + pck.type = type; + return pck; +} + +std::vector netprot::recvPacks(SOCKET sock, Buffer* buf) { + std::vector lsPck; + int len = 0, end = 0; + bool pck_received = false; + char* cursor = nullptr; + + while (true) { + while (!pck_received) { + int bytes = recv(sock, &buf->ptr[len], buf->len - len, 0); + if (bytes < 0) // si recv() retourne -1; ça veut dire qu'il y a plus rien a lire. + return lsPck; + len += bytes; + // TODO: Voir si on trouve un footer (5 '\0' d'affilee). + // Si oui, mettre l'index du debut du footer dans + // la variable "end" et mettre pck_received a true. + } + + cursor = &buf->ptr[end]; + + lsPck.push_back(getPack(buf)); + + while (*cursor == '\0') { + cursor++; + end++; + } + + if (cursor) { // mettre le début du prochain paquet au début du buffer. + memcpy(buf->ptr, cursor, buf->len - end); // et voir s'il y a en un autre + len = 0; + pck_received = true; + } + } +} + +template <> +void netprot::sendPack(SOCKET sock, Packet* pack, char** buf, uint32_t* buflen) { + switch (pack->type) { + case PACKET_TYPE::INPUT: + sendPack(sock, (Input*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::OUTPUT: + sendPack(sock, (Output*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::SYNC: + sendPack(sock, (Sync*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::TEAMINF: + sendPack(sock, (TeamInfo*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::PLAYINF: + sendPack(sock, (PlayerInfo*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::LOGINF: + sendPack(sock, (LoginInfo*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::CHUNKMOD: + //sendPack(sock, (ChunkMod*)pack->ptr, buf, buflen); + case PACKET_TYPE::PLAYERMOD: + //sendPack(sock, (PlayerMod*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::PICKUPMOD: + //sendPack(sock, (PickupMod*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::GAMEINFO: + sendPack(sock, (GameInfo*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::ENDINFO: + //sendPack(sock, (EndInfo*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::CHAT: + sendPack(sock, (Chat*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::ERRLOG: + sendPack(sock, (ErrorLog*)pack->ptr, buf, buflen); + return; + case PACKET_TYPE::LAST_PACK: [[fallthrough]]; + case PACKET_TYPE::ERR: [[fallthrough]]; + default: + return; + } +} + +template <> +void netprot::sendPackTo(SOCKET sock, Packet* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad) { + switch (pack->type) { + case PACKET_TYPE::INPUT: + sendPackTo(sock, (Input*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::OUTPUT: + sendPackTo(sock, (Output*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::SYNC: + sendPackTo(sock, (Sync*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::TEAMINF: + sendPackTo(sock, (TeamInfo*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::PLAYINF: + sendPackTo(sock, (PlayerInfo*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::LOGINF: + sendPackTo(sock, (LoginInfo*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::CHUNKMOD: + //sendPackTo(sock, (ChunkMod*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::PLAYERMOD: + //sendPackTo(sock, (PlayerMod*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::PICKUPMOD: + //sendPackTo(sock, (PickupMod*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::GAMEINFO: + sendPackTo(sock, (GameInfo*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::ENDINFO: + //sendPackTo(sock, (EndInfo*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::CHAT: + sendPackTo(sock, (Chat*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::ERRLOG: + sendPackTo(sock, (ErrorLog*)pack->ptr, buf, buflen, sockad); + return; + case PACKET_TYPE::LAST_PACK: [[fallthrough]]; + case PACKET_TYPE::ERR: [[fallthrough]]; + default: + return; + } } diff --git a/SQCSim-common/netprotocol.h b/SQCSim-common/netprotocol.h index d7c7a93..987e5fe 100644 --- a/SQCSim-common/netprotocol.h +++ b/SQCSim-common/netprotocol.h @@ -1,23 +1,35 @@ #ifndef NETPROTOCOL_H__ #define NETPROTOCOL_H__ -#include "define.h" #include +#include "define.h" #include "vector3.h" -/* Protocole Particulier de Partie à Plusieurs Personnes (PPPPP) */ +/* Protocole Particulier de Partie a Plusieurs Personnes (PPPPP) */ // Packet: packet[0] = PacketType, packet[1..n-1] = {packet} namespace netprot { - typedef uint8_t PacketType; - enum PACKET_TYPE { + enum class PACKET_TYPE: uint8_t { ERR, INPUT, OUTPUT, SYNC, TEAMINF, SELFINF, PLAYINF, LOGINF, CHUNKMOD, PLAYERMOD, PICKUPMOD, GAMEINFO, ENDINFO , CHAT, ERRLOG, LAST_PACK }; + + struct Buffer { // Pour pouvoir rendre l'utilisation des buffers plus clean. + char* ptr = new char[BUFFER_LENGTH]; + uint32_t len = BUFFER_LENGTH; + + ~Buffer() { delete[] ptr; } + void rstLen() { len = BUFFER_LENGTH; } + }; + + 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. + PACKET_TYPE type = PACKET_TYPE::ERR; + }; struct Keys { bool forward, @@ -33,7 +45,11 @@ namespace netprot { bool jumping, shooting, hit, - powerup; + powerup, + dead, + still, + jumpshot, + running; }; struct Input { // cli -> srv UDP ~frame @@ -58,29 +74,39 @@ namespace netprot { uint16_t ammo = 0; uint8_t 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]; uint64_t id = 0; + TeamInfo() {} + TeamInfo(TeamInfo* tem) : id(tem->id) { strcpy(tem->name, name); } }; struct LoginInfo { // cli <-> srv TCP once char name[32]; uint64_t sid = 0, tid = 0; + LoginInfo() {} + LoginInfo(LoginInfo* ply): sid(ply->sid), tid(ply->tid) { strcpy(ply->name, name); } }; struct PlayerInfo { // cli <-> srv TCP once char name[32]; uint64_t id = 0, tid = 0; + PlayerInfo() {} + PlayerInfo(PlayerInfo* log) : id(log->id), tid(log->tid) { strcpy(log->name, name); } }; struct GameInfo { // cli <-> srv TCP event (before game start)/ once uint64_t seed; uint32_t countdown; - uint8_t gameType; // TOOD: enum. + uint8_t gameType; // TODD: enum. + GameInfo() {} + GameInfo(GameInfo* gam) : seed(gam->seed), countdown(gam->countdown), gameType(gam->gameType) {} }; struct Chat { // cli <-> srv TCP event @@ -88,11 +114,15 @@ namespace netprot { dest_id = 0, dest_team_id = 0; char mess[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); } }; struct ErrorLog { // srv -> cli TCP event char mess[140]; bool is_fatal; + ErrorLog() {}; + ErrorLog(ErrorLog* err) : is_fatal(err->is_fatal) { strcpy(err->mess, mess); } }; void Serialize(Input* in, char* buf[], uint32_t* buflen); // cli @@ -115,6 +145,61 @@ namespace netprot { bool Deserialize(Chat* chat, char* buf, const uint32_t buflen); // srv/cli bool Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen); // srv - PacketType getType(char* buf, uint32_t buflen); // srv/cli -} + PACKET_TYPE getType(char* buf, uint32_t buflen); + + Packet getPack(char* buf, uint32_t buflen); + Packet getPack(Buffer* buf); + + bool emptyPack(Packet pck); + + Packet makePack(void* ptr, PACKET_TYPE type); // Pour pouvoir faire une liste de stock a supprimer sans avoir a en faire une pour chaque type. + + template void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen); + template void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad); + + template void sendPack(SOCKET sock, T* pack, Buffer* buf); + template void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad); + + std::vector recvPacks(SOCKET sock, Buffer* buf); + + template + void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) { + netprot::Serialize(pack, buf, buflen); + memset(&buf[*buflen], '\0', sizeof(uint64_t) + sizeof(uint8_t)); + buflen += (sizeof(uint64_t) + sizeof(uint8_t)); + send(sock, *buf, *buflen, 0); + *buflen = BUFFER_LENGTH; + } + + template + void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad) { + sockaddr_in addr = *sockad; + netprot::Serialize(pack, buf, buflen); + memset(&buf[*buflen], '\0', sizeof(uint64_t) + sizeof(uint8_t)); + buflen += (sizeof(uint64_t) + sizeof(uint8_t)); + sendto(sock, *buf, *buflen, 0, (sockaddr*)&addr, sizeof(addr)); + *buflen = BUFFER_LENGTH; + } + + template + void sendPack(SOCKET sock, T* pack, Buffer* buf) { + netprot::Serialize(pack, &buf->ptr, &buf->len); + memset(&buf->ptr[buf->len], '\0', sizeof(uint64_t) + sizeof(uint8_t)); + buf->len += sizeof(uint64_t) + sizeof(uint8_t); + send(sock, buf->ptr, buf->len, 0); + buf->rstLen(); + } + + template + void sendPackTo(SOCKET sock, T* pack, Buffer* buf, sockaddr_in* sockad) { + sockaddr_in addr = *sockad; + netprot::Serialize(pack, &buf->ptr, &buf->len); + memset(&buf->ptr[buf->len], '\0', sizeof(uint64_t) + sizeof(uint8_t)); + buf->len += sizeof(uint64_t) + sizeof(uint8_t); + sendto(sock, buf->ptr, buf->len, 0, (sockaddr*)&addr, sizeof(addr)); + buf->rstLen(); + } + + +}; #endif diff --git a/SQCSim-common/player.cpp b/SQCSim-common/player.cpp index 15e935d..5c92653 100644 --- a/SQCSim-common/player.cpp +++ b/SQCSim-common/player.cpp @@ -4,10 +4,12 @@ Player::Player(const Vector3f& position, float rotX, float rotY) : m_position(position), m_rotX(rotX), m_rotY(rotY) { m_velocity = Vector3f(0, 0, 0); m_airborne = true; - m_hp = 1.0f; //TODO: Remettre à 1.0f + m_hp = 1.0f; //TODO: Remettre � 1.0f m_username = "Zelda Bee-Bop56"; } +Player::~Player() {} + void Player::TurnLeftRight(float value) { m_rotY += value; if (m_rotY > 360) m_rotY = 0; @@ -165,7 +167,7 @@ Player::Sound Player::ApplyPhysics(Vector3f input, World* world, float elapsedTi m_position += m_velocity; - static float bobbingtime = 0; // Gestion de la caméra + static float bobbingtime = 0; // Gestion de la cam�ra static bool leftright = false; static bool isStep = false; if (bobbingtime <= 360.f) @@ -226,4 +228,9 @@ void Player::InflictDamage(float hitPoints) } + +uint64_t Player::getId() const { return id; } + +Vector3f Player::InterpolatePosition(const Vector3f& vec1, const Vector3f& vec2, const Timestamp& tim1, const Timestamp& tim2, const Timestamp& now) { + return Vector3f(); } diff --git a/SQCSim-common/player.h b/SQCSim-common/player.h index 59d7776..eedbf74 100644 --- a/SQCSim-common/player.h +++ b/SQCSim-common/player.h @@ -12,6 +12,8 @@ public: enum Sound { NOSOUND, STEP, FALL }; Player(const Vector3f& position, float rotX = 0, float rotY = 0); + ~Player(); + void TurnLeftRight(float value); void TurnTopBottom(float value); Vector3f GetInput(bool front, bool back, bool left, bool right, bool jump, bool dash, float elapsedTime); @@ -30,11 +32,15 @@ public: void InflictDamage(float hitPoints); private: + uint64_t getId() const; + +protected: Vector3f m_position; Vector3f m_velocity; Vector3f m_direction; std::string m_username; + uint64_t id = 0; float m_rotX = 0; float m_rotY = 0; @@ -43,6 +49,9 @@ private: float m_hp; bool m_airborne; + + Vector3f InterpolatePosition(const Vector3f& vec1, const Vector3f& vec2, const Timestamp& tim1, const Timestamp& tim2, const Timestamp& now); + }; #endif //_PLAYER_H__ diff --git a/SQCSim-common/world.cpp b/SQCSim-common/world.cpp index 1be12e7..c18c32c 100644 --- a/SQCSim-common/world.cpp +++ b/SQCSim-common/world.cpp @@ -6,6 +6,12 @@ World::~World() {} Array2d& World::GetChunks() { return m_chunks; } +void World::BuildWorld() { + for (int x = 0; x < WORLD_SIZE_X; ++x) + for (int y = 0; y < WORLD_SIZE_Y; ++y) + m_chunks.Set(x, y, new Chunk(x + m_center[0], y + m_center[1], m_seed)); +} + void World::SetSeed(uint64_t seed) { m_seed = seed; } diff --git a/SQCSim-common/world.h b/SQCSim-common/world.h index 0cc628d..8a166af 100644 --- a/SQCSim-common/world.h +++ b/SQCSim-common/world.h @@ -21,6 +21,7 @@ public: ~World(); Array2d& GetChunks(); + void BuildWorld(); void SetSeed(uint64_t seed); @@ -45,7 +46,7 @@ private: unsigned int m_center[2] = { UINT16_MAX / 2 - WORLD_SIZE_X, UINT16_MAX / 2 - WORLD_SIZE_Y }; - void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]); + //void UpdateChunk(int& updates, unsigned int chx, unsigned int chy, BlockInfo* blockinfo[BTYPE_LAST]); void UpdateWorld(const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]); void TransposeWorld(Vector3f& player, Bullet* bullets[MAX_BULLETS]); diff --git a/SQCSim-srv/SQCSim-srv.vcxproj b/SQCSim-srv/SQCSim-srv.vcxproj index 525fc03..d080276 100644 --- a/SQCSim-srv/SQCSim-srv.vcxproj +++ b/SQCSim-srv/SQCSim-srv.vcxproj @@ -76,6 +76,7 @@ true WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console @@ -90,7 +91,7 @@ true WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true - Default + stdcpp20 Console @@ -105,6 +106,7 @@ true _DEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console @@ -119,6 +121,7 @@ true NDEBUG;_CONSOLE;%(PreprocessorDefinitions) true + stdcpp20 Console diff --git a/SQCSim-srv/cmake/CMakeLists.txt b/SQCSim-srv/cmake/CMakeLists.txt index 4a1f624..ef8f3f2 100644 --- a/SQCSim-srv/cmake/CMakeLists.txt +++ b/SQCSim-srv/cmake/CMakeLists.txt @@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.18.4) project(SQCSim-Server VERSION 0.1) add_compile_options("-Wno-narrowing") -set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD 20) set(CMAKE_STANDARD_REQUIRED True) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "../out") diff --git a/SQCSim-srv/connection.cpp b/SQCSim-srv/connection.cpp index 356396f..079b0fb 100644 --- a/SQCSim-srv/connection.cpp +++ b/SQCSim-srv/connection.cpp @@ -4,8 +4,8 @@ Connection::Connection(SOCKET sock, sockaddr_in sockaddr, - netprot::LoginInfo log, - netprot::PlayerInfo play): + LoginInfo log, + PlayerInfo play): m_sock(sock), m_addr(sockaddr), m_loginfo(log), @@ -13,9 +13,7 @@ Connection::Connection(SOCKET sock, } -Connection::~Connection() { - closesocket(m_sock); -} +Connection::~Connection() { closesocket(m_sock); } uint64_t Connection::GetHash(bool self) const { return self? m_loginfo.sid: m_playinfo.id; } @@ -23,19 +21,17 @@ uint64_t Connection::GetTeamHash() const { return m_loginfo.tid; } std::string Connection::GetName() const { return m_loginfo.name; } -void Connection::AddInput(netprot::Input in) { - m_input_manifest.insert({ in.timestamp, in }); -} +void Connection::AddInput(Input in) { m_input_manifest.insert({ in.timestamp, in }); } -netprot::Output* Connection::getOutput(Timestamp time) { +Output* Connection::getOutput(Timestamp time) { auto out = m_output_manifest.find(time); if (out != m_output_manifest.end()) return &out->second; return nullptr; } -netprot::Sync Connection::getSync(Timestamp time) { - netprot::Sync sync; +Sync Connection::getSync(Timestamp time) { + Sync sync; auto out = m_output_manifest.find(time); if (out != m_output_manifest.end()) { sync.timestamp = out->second.timestamp; @@ -45,10 +41,15 @@ netprot::Sync Connection::getSync(Timestamp time) { return sync; } +SOCKET Connection::getSock() const { return m_sock; } + +PlayerInfo* Connection::getInfo() const { return (PlayerInfo*)&m_playinfo; } + +sockaddr_in* Connection::getAddr() const { return (sockaddr_in*)&m_addr; } + void Connection::CleanInputManifest(Timestamp time) { auto wat = m_input_manifest.find(time); while (wat != m_input_manifest.begin()) m_input_manifest.erase(wat--); - } diff --git a/SQCSim-srv/connection.h b/SQCSim-srv/connection.h index 6dee988..b7a69ee 100644 --- a/SQCSim-srv/connection.h +++ b/SQCSim-srv/connection.h @@ -8,35 +8,40 @@ #include "../SQCSim-common/netprotocol.h" #include "define.h" +using namespace netprot; + class Connection { public: Connection( SOCKET sock, sockaddr_in sockaddr, - netprot::LoginInfo log, - netprot::PlayerInfo play); + LoginInfo log, + PlayerInfo play); ~Connection(); - Player* player = nullptr; + std::unique_ptr player = nullptr; uint64_t GetHash(bool self = true) const; uint64_t GetTeamHash() const; std::string GetName() const; - void AddInput(netprot::Input in); - netprot::Output* getOutput(Timestamp time); - netprot::Sync getSync(Timestamp time); + void AddInput(Input in); + Output* getOutput(Timestamp time); + Sync getSync(Timestamp time); + SOCKET getSock() const; + PlayerInfo* getInfo() const; + sockaddr_in* getAddr() const; void CleanInputManifest(Timestamp time); private: - std::map m_input_manifest; - std::map m_output_manifest; - std::map m_chatlog; + std::map m_input_manifest; + std::map m_output_manifest; + std::map m_chatlog; SOCKET m_sock; sockaddr_in m_addr; - netprot::LoginInfo m_loginfo; - netprot::PlayerInfo m_playinfo; + LoginInfo m_loginfo; + PlayerInfo m_playinfo; }; -#endif \ No newline at end of file +#endif diff --git a/SQCSim-srv/define.h b/SQCSim-srv/define.h index 626a26a..e30bd49 100644 --- a/SQCSim-srv/define.h +++ b/SQCSim-srv/define.h @@ -9,9 +9,6 @@ #define MAX_CONNECTIONS 16 #define ID_LIST_SIZE 127 -#define BUFFER_LENGTH 150 - -typedef unsigned char LogDest; -enum LOG_DEST { CONSOLE, LOGFILE, LOG_LAST }; +#define SRV_MANUAL_SETUP true #endif diff --git a/SQCSim-srv/main.cpp b/SQCSim-srv/main.cpp index a1e104d..98d39f9 100644 --- a/SQCSim-srv/main.cpp +++ b/SQCSim-srv/main.cpp @@ -1,9 +1,8 @@ #include "server.h" int main() { - Server* server = new Server(); + std::unique_ptr server = std::make_unique(); if (server->Init() == 0) if (server->Ready() == 0) server->Run(); - delete server; } \ No newline at end of file diff --git a/SQCSim-srv/server.cpp b/SQCSim-srv/server.cpp index cbda844..983ed59 100644 --- a/SQCSim-srv/server.cpp +++ b/SQCSim-srv/server.cpp @@ -1,6 +1,6 @@ #include "server.h" -Server::Server(LogDest log) { +Server::Server(LOG_DEST log) { m_log = log; if (log == LOG_DEST::LOGFILE) { m_logfile = std::ofstream("server.log", std::ofstream::out); @@ -17,7 +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(); #ifdef _WIN32 WSACleanup(); #endif @@ -65,70 +68,105 @@ int Server::Init() { } int Server::Ready() { + 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 { + m_game.countdown = std::stoi(m_buf.ptr); + } catch(const std::exception& e) { + Log(e.what(), true, false); + m_game.countdown = 0; + } + } while (m_game.countdown < 1); + 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) { + Log(e.what(), true, false); + m_game.seed = 0; + } + } 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) { + Log(e.what(), true, false); + nbrjoueurs = 0; + } + if (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS) + Log("Nombre de joueurs invalide.", true, false); + } while (nbrjoueurs <= 0 || nbrjoueurs > MAX_CONNECTIONS); + + m_game.gameType = 1; + if (listen(m_sock_tcp, MAX_CONNECTIONS) < 0) { - Log("Écoute sur le port TCP.", true, true); + Log("Ecoute sur le port TCP.", true, true); return 1; } - char* buf = new char[150]; - uint32_t buflen = 150; - bool readystart = false; - srand(time(NULL)); - - Log("À l'écoute sur le port: " + std::to_string(SRV_PORT), false, false); - buildIdList(ID_LIST_SIZE); - - m_game.countdown = 360; - m_game.gameType = 1; - m_game.seed = 9370707; - + + Log("A l'ecoute sur le port: " + std::to_string(SRV_PORT), false, false); + while (!readystart) { sockaddr_in sockad; - unsigned int addrlen = sizeof(sockad); + addrlen_t addrlen = sizeof(sockad); SOCKET sock = accept(m_sock_tcp, (sockaddr*)&sockad, &addrlen); if (sock < 0) Log("Erreur de connexion", true, false); else if (sock > 0) { - std::string str = "Nouvelle connection provenant de: "; - char* strbuf = new char[BUFFER_LENGTH]; - uint32_t strbuflen = BUFFER_LENGTH; + std::string str = "Nouvelle connexion provenant de: "; + str.append(inet_ntop(AF_INET, &sockad.sin_addr, m_buf.ptr, m_buf.len)).append(": ").append(std::to_string(sockad.sin_port)); - str.append(inet_ntop(AF_INET, &sockad.sin_addr, strbuf, strbuflen)).append(": ").append(std::to_string(sockad.sin_port)); + if (recv(sock, m_buf.ptr, m_buf.len, 0) > 0) { + PlayerInfo play; - if (recv(sock, buf, buflen, 0) > 0) { - netprot::LoginInfo log; - netprot::PlayerInfo play; - if (netprot::Deserialize(&log, buf, buflen)) { - log.sid = getUniqueId(); - - log.tid = 0; - - str.append(" Nom: ").append(log.name); - Log(str, false, false); - str = ""; - - str.append(log.name).append(" SID: [").append(std::to_string(log.sid).append("]")); - Log(str, false, false); - - //netprot::Serialize(&log, &buf, &buflen); - //send(sock, buf, buflen, 0); - //buflen = 150; - sendPack(sock, &log, &buf, &buflen); - - play.id = getUniqueId(); - memcpy(play.name, log.name, std::strlen(log.name) + 1); - play.tid = log.tid; - - //netprot::Serialize(&m_game, &buf, &buflen); - //send(sock, buf, buflen, 0); - sendPack(sock, &m_game, &buf, &buflen); - Connection* conn = new Connection(sock, sockad, log, play); - - m_players[log.sid] = conn; - readystart = true; + Packet pck = getPack(&m_buf); + if (pck.type != PACKET_TYPE::LOGINF) { + Log("Paquet invalide.", true, false); + if (pck.type != PACKET_TYPE::ERR) + 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; + + log->sid = getUniqueId(); + log->tid = 0; // TODO: À changer si on implemente un mode en equipe. + + 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(sock, log, &m_buf.ptr, &m_buf.len); + + play.id = getUniqueId(); + strcpy(play.name, log->name); + + play.tid = log->tid; + + sendPack(sock, &m_game, &m_buf.ptr, &m_buf.len); + std::unique_ptr conn = std::make_unique(sock, sockad, *log, play); + + for (auto& [key, player] : m_players) { + sendPack(player->getSock(), &play, &m_buf); // Envoyer les infos de joueur distant aux joueurs d�j� connect�s + sendPack(sock, player->getInfo(), &m_buf); // et envoyer les infos des joueurs distants au nouveau joueur. + } + + m_players[log->sid] = std::move(conn); + + delete log; + + if (++nbrconn >= nbrjoueurs) + readystart = true; } } } @@ -136,14 +174,61 @@ int Server::Ready() { } void Server::Run() { + Input in; + sockaddr_in sockad; + addrlen_t socklen = sizeof(sockad); + + Log("Debut de la partie...", false, false); - Log("Partie en cours...", false, false); + m_world = std::make_unique(); + 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(Vector3f(8.5f, CHUNK_SIZE_Y + 1.8f, 8.5f)); + Sync sync; + sync.position = conn->player->GetPosition(); + sync.hp = conn->player->GetHP(); + sync.sid = key; + sync.ammo = 0; + sync.timestamp = 0; + sync.timer = m_game.countdown; + sendPack(conn->getSock(), &sync, &m_buf); + } + + 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); + } + } } inline std::string Server::LogTimestamp() { time_t rawtime; - struct tm timeinfo; - char buffer[80]; + tm timeinfo; + char buffer[50]; time(&rawtime); @@ -161,30 +246,39 @@ inline std::string Server::LogTimestamp() { void Server::Log(std::string str, bool is_error = false, bool is_fatal = false) { switch (m_log) { - case LOG_DEST::LOGFILE: - m_logfile << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl; - break; - case LOG_DEST::CONSOLE: - default: - std::cout << LogTimestamp() << (is_fatal ? "FATAL " : "") << (is_error ? "ERROR " : "") << str << std::endl; - break; + 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; } if (is_fatal) { + if (m_logfile.is_open()) + m_logfile.close(); if (m_sock_udp) 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(); #ifdef _WIN32 WSACleanup(); #endif + exit(-1); } } void Server::buildIdList(size_t size) { std::set lst; - do lst.insert(((uint64_t)rand() << 25) % 8675309); // EIGHT SIX SEVENFIVE THREE AUGHT NIIIIIIiIIiiIiINE! + srand(time(NULL)); + do lst.insert(((uint64_t)rand() << 32 | rand())); while (lst.size() < size); m_ids = std::vector(lst.begin(), lst.end()); @@ -195,133 +289,3 @@ uint64_t Server::getUniqueId() { m_ids.pop_back(); return id; } - -// Test serialize/deserialize: -/* - netprot::LoginInfo log, log2; - std::cout << "Nom? "; - std::cin.getline(log.name, 32); // NO! STD::CIN >> VARIABLE;! EVEEEEEERRRR!!! - log.sid = 12345; - char* buf = new char[150]; - uint32_t buflen = 150; - - netprot::Serialize(&log, &buf, &buflen); - - bool is_work = netprot::Deserialize(&log2, buf, buflen); - - std::string str; - str.append(is_work ? "Y " : "N ").append(log2.name).append(": ").append(std::to_string(log2.sid)); - - Log(str, false, false); -*/ - - -///* Recevoir paquet */ -//while (true) { -// char buffer[2048]; -// sockaddr_in client; -// -//#ifdef _WIN32 // Mais pourquoi? -// int clen = sizeof(client); -//#else -// unsigned int clen = sizeof(client); -//#endif -// -// int count = recvfrom(socket_udp, buffer, sizeof(buffer) - 1, 0, (sockaddr*)&client, &clen); -// -// if (count < 0) { -// Log("Erreur de reception de paquet.", socket_udp); -// return 4; -// } -// -// buffer[count] = '\0'; -// -// /* Gérer le paquet reçu */ -// std::string commande(buffer); -// -// if (commande.find("echo ") == 0) { /* ECHO */ -// std::string::size_type pos = commande.find(' '); -// std::string parametres = commande.substr(pos + 1); -// -// sendto(socket_udp, parametres.c_str(), parametres.length(), 0, (const sockaddr*)&client, sizeof(client)); -// } -// else if (commande.find("date ") == 0) { /* DATE */ -// time_t rawtime; -// struct tm* timeinfo = new tm(); -// char tbuffer[80]; -// -// time(&rawtime); -// -//#ifdef _WIN32 -// localtime_s(timeinfo, &rawtime); -//#else -// localtime_r(&rawtime, timeinfo); -//#endif -// -// strftime(tbuffer, 80, "%a %b %e %T %G", timeinfo); -// -// sendto(socket_udp, tbuffer, sizeof(tbuffer), 0, (const sockaddr*)&client, sizeof(client)); -// delete timeinfo; -// } -// else if (commande.find("ping ") == 0) { /* PING */ -// sendto(socket_udp, "pong", sizeof("pong"), 0, (const sockaddr*)&client, sizeof(client)); -// } -// else if (commande.find("usager ") == 0) { /* USAGER */ -// std::string user; -// -//#ifdef _WIN32 -// wchar_t userbuf[30]; -// DWORD usersize = 30; -// -// GetUserNameW(userbuf, &usersize); -// -// std::wstring wuser = userbuf; -// user = std::string(wuser.begin(), wuser.end()); -//#else -// char ptr[30]; -// getlogin_r(ptr, sizeof(ptr) - 1); -// user = std::string(ptr); -//#endif -// -// sendto(socket_udp, user.c_str(), user.length(), 0, (const sockaddr*)&client, sizeof(client)); -// } -// else if (commande.find("exec ") == 0) { /* EXEC */ -// std::string::size_type pos = commande.find(' '); -// std::string parametres = commande.substr(pos + 1); -// -// FILE* pipe = nullptr; -// char buffer[301]; // 300 caractères + '\0' -// std::string reponse; -// -// pipe = popen(parametres.c_str(), "r"); -// -// if (!pipe) -// reponse = "Erreur de commande!"; -// else while (!feof(pipe)) { -// if (fgets(buffer, sizeof(buffer) - 1, pipe)) -// reponse += buffer; -// } -// -// if (pipe) -// pclose(pipe); -// -// if (reponse.length() > 300) -// reponse = reponse.substr(0, 300); -// else if (reponse.length() < 1) -// reponse = "OK!"; -// -// sendto(socket_udp, reponse.c_str(), reponse.length(), 0, (const sockaddr*)&client, sizeof(client)); -// } -// else if (commande.find("bye ") == 0) { /* BYE */ -// Log("", 0); // Message d'erreur pas de message d'erreur! -// return 0; -// } -// else sendto(socket_udp, "huh?", sizeof("huh?"), 0, (const sockaddr*)&client, sizeof(client)); /* DEFAULT */ -//} -// -///* Ce bout de code ne devrait theoriquement jamais etre atteint, mais au cas. */ -//Log("", 0); -//return 0; -//return false; -//} -// diff --git a/SQCSim-srv/server.h b/SQCSim-srv/server.h index 6c77038..10b7709 100644 --- a/SQCSim-srv/server.h +++ b/SQCSim-srv/server.h @@ -10,9 +10,13 @@ #include "define.h" #include "connection.h" +using namespace netprot; + class Server { public: - Server(LogDest log = LOG_DEST::CONSOLE); + enum LOG_DEST: unsigned char { CONSOLE, LOGFILE, LOG_LAST }; + + Server(LOG_DEST log = LOG_DEST::CONSOLE); ~Server(); int Init(); @@ -20,35 +24,31 @@ public: void Run(); private: + #ifdef _WIN32 WSADATA m_wsaData; #endif SOCKET m_sock_udp = 0, m_sock_tcp = 0; - LogDest m_log; + LOG_DEST m_log; std::ofstream m_logfile; - std::map m_players; - std::map m_chatlog; - std::vector m_ids; - netprot::GameInfo m_game; + Buffer m_buf; - World* m_world = nullptr; + std::map> m_players; + std::map m_chatlog; + std::vector m_ids; + GameInfo m_game; + + std::unique_ptr m_world = nullptr; + const bool m_manual_setup = SRV_MANUAL_SETUP; std::string LogTimestamp(); void Log(std::string str, bool is_error, bool is_fatal); void buildIdList(size_t size); - uint64_t getUniqueId(); - template void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen); + uint64_t getUniqueId(); }; -template -void Server::sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen) { - netprot::Serialize(pack, buf, buflen); - send(sock, *buf, *buflen, 0); - *buflen = BUFFER_LENGTH; -} - #endif diff --git a/SQCSim2021/SQCSim2021.vcxproj b/SQCSim2021/SQCSim2021.vcxproj index d120d7b..fc67c42 100644 --- a/SQCSim2021/SQCSim2021.vcxproj +++ b/SQCSim2021/SQCSim2021.vcxproj @@ -25,13 +25,14 @@ + - + @@ -40,13 +41,14 @@ + - + @@ -130,7 +132,7 @@ Level3 Disabled WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions) - stdcpp17 + stdcpp20 Console @@ -145,7 +147,7 @@ Level3 Disabled WIN32;_DEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions) - stdcpp17 + stdcpp20 Console @@ -162,7 +164,7 @@ true true WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions) - stdcpp17 + stdcpp20 AnySuitable Speed Fast @@ -184,7 +186,7 @@ true true WIN32;NDEBUG;_CONSOLE;NOMINMAX;%(PreprocessorDefinitions) - stdcpp17 + stdcpp20 AnySuitable Speed Fast diff --git a/SQCSim2021/SQCSim2021.vcxproj.filters b/SQCSim2021/SQCSim2021.vcxproj.filters index 3bf0928..5c8a864 100644 --- a/SQCSim2021/SQCSim2021.vcxproj.filters +++ b/SQCSim2021/SQCSim2021.vcxproj.filters @@ -47,7 +47,10 @@ Fichiers d%27en-tête - + + Fichiers d%27en-tête + + Fichiers d%27en-tête @@ -88,7 +91,10 @@ Fichiers sources - + + Fichiers sources + + Fichiers sources diff --git a/SQCSim2021/cmake/CMakeLists.txt b/SQCSim2021/cmake/CMakeLists.txt index fbe850f..4da3eb4 100644 --- a/SQCSim2021/cmake/CMakeLists.txt +++ b/SQCSim2021/cmake/CMakeLists.txt @@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.18.4) project(SQCSim-Client VERSION 0.8) -set(CMAKE_CXX_STANDARD 17) +set(CMAKE_CXX_STANDARD 20) set(CMAKE_STANDARD_REQUIRED True) set(CMAKE_BUILD_DIRECTORY "./build") @@ -50,7 +50,8 @@ add_executable(SQCSim-client "../textureatlas.cpp" "../tool.cpp" "../vertexbuffer.cpp" - "../worldrenderer.cpp" + "../renderer.cpp" + "../remoteplayer.cpp" "../main.cpp" ) diff --git a/SQCSim2021/connector.cpp b/SQCSim2021/connector.cpp index 31e1b81..3611a37 100644 --- a/SQCSim2021/connector.cpp +++ b/SQCSim2021/connector.cpp @@ -42,7 +42,7 @@ int Connector::Init() { return 0; } -int Connector::Connect(char* srv_addr, std::string name) { +int Connector::Connect(const char* srv_addr, std::string name) { sockaddr_in add; m_srvsockaddr.sin_family = AF_INET; m_srvsockaddr.sin_port = htons(SRV_PORT); @@ -54,44 +54,60 @@ int Connector::Connect(char* srv_addr, std::string name) { if (connect(m_sock_tcp, (sockaddr*)&m_srvsockaddr, sizeof(m_srvsockaddr)) < 0) { std::cout << "Échec de la connexion." << std::endl; + return 2; } - char* buf = new char[150]; - uint32_t buflen = 150; + flag_t flag = 1; + if (ioctl(m_sock_tcp, SOCK_NONBLOCK, &flag) < 0) { + std::cout << "Impossible de mettre le socket en mode non-bloquant." << std::endl; + return 3; + } + + netprot::Buffer bf; netprot::LoginInfo log; - memcpy(&log.name, name.c_str(), name.size() + 1); + strcpy(log.name, name.c_str()); - netprot::Serialize(&log, &buf, &buflen); + netprot::sendPack(m_sock_tcp, &log, &bf); - int se = send(m_sock_tcp, buf, buflen, 0); + bool ready = false; + int errors = 0; + std::vector lsPck; + while (!ready) { + lsPck = netprot::recvPacks(m_sock_tcp, &bf); - delete[] buf; - buf = new char[150] {0}; - buflen = 150; - int rpack = 0; - - while (rpack < 2) { - recv(m_sock_tcp, buf, buflen, 0); - - switch (netprot::getType(buf, buflen)) { - case netprot::PACKET_TYPE::LOGINF: - if (!netprot::Deserialize(&m_loginfo, buf, buflen)) { - std::cout << "Packet LoginInfo invalide." << std::endl; - return 2; + for (auto& pck : lsPck) { + bool bypass_delete = false; + netprot::PlayerInfo* pl = nullptr; + switch (pck.type) { + using enum netprot::PACKET_TYPE; + case LOGINF: + m_loginfo = netprot::LoginInfo((netprot::LoginInfo*)pck.ptr); + break; + case GAMEINFO: + m_gameinfo = netprot::GameInfo((netprot::GameInfo*)pck.ptr); + break; + case PLAYINF: + pl = (netprot::PlayerInfo*)pck.ptr; + m_players[pl->id] = pl; + bypass_delete = true; + break; + case TEAMINF: + // TODO: Faire dequoi avec TeamInfo si on fini par avoir des teams. + break; + case SYNC: + m_origin = netprot::Sync((netprot::Sync*)pck.ptr); + ready = true; + break; + default: + errors++; + break; } - ++rpack; - break; - case netprot::PACKET_TYPE::GAMEINFO: - if (!netprot::Deserialize(&m_gameinfo, buf, buflen)) { - std::cout << "Packet GameInfo invalide." << std::endl; - return 3; - } - ++rpack; - break; - default: - std::cout << "Packet invalide." << std::endl; - break; + if (!bypass_delete) + netprot::emptyPack(pck); } + lsPck.clear(); + if (errors > 100) + return 4; } return 0; } @@ -99,3 +115,5 @@ int Connector::Connect(char* srv_addr, std::string name) { uint64_t Connector::getId() const { return m_loginfo.sid; } unsigned int Connector::getSeed() const { return m_gameinfo.seed; } + +netprot::Sync Connector::getOrigin() const { return m_origin; } diff --git a/SQCSim2021/connector.h b/SQCSim2021/connector.h index 297be6f..4fd883e 100644 --- a/SQCSim2021/connector.h +++ b/SQCSim2021/connector.h @@ -11,26 +11,32 @@ public: ~Connector(); int Init(); - int Connect(char* srv_addr, std::string name); + int Connect(const char* srv_addr, std::string name); uint64_t getId() const; unsigned int getSeed() const; + netprot::Sync getOrigin() const; + //void SendInput(); //int Sync(); + + SOCKET m_sock_udp = 0, + m_sock_tcp = 0; + sockaddr_in m_srvsockaddr; + + // void updateRemotePlayers(std::map rplayers); + + std::map m_players; private: #ifdef _WIN32 WSADATA m_wsaData; #endif std::map m_inputmanifest; - std::map m_players; std::map m_teams; netprot::LoginInfo m_loginfo; netprot::GameInfo m_gameinfo; - - sockaddr_in m_srvsockaddr; - SOCKET m_sock_udp = 0, - m_sock_tcp = 0; + netprot::Sync m_origin; }; #endif diff --git a/SQCSim2021/define.h b/SQCSim2021/define.h index 67c49c3..7f4c4af 100644 --- a/SQCSim2021/define.h +++ b/SQCSim2021/define.h @@ -20,7 +20,6 @@ #include #endif -#define NETWORK_TEST false #define SRV_ADDR "127.0.0.1" #define COUNTDOWN 300 diff --git a/SQCSim2021/engine.cpp b/SQCSim2021/engine.cpp index 2d741e7..f2ce768 100644 --- a/SQCSim2021/engine.cpp +++ b/SQCSim2021/engine.cpp @@ -279,6 +279,9 @@ void Engine::Init() { abort(); } + uint64_t seed = SEED; + char ch; + glDisable(GL_FRAMEBUFFER_SRGB); glEnable(GL_DEPTH_TEST); glEnable(GL_STENCIL_TEST); @@ -308,31 +311,59 @@ void Engine::Init() { // Array pour les balles. for (int x = 0; x < MAX_BULLETS; ++x) { m_bullets[x] = nullptr; - m_whoosh[x] = nullptr; // = m_audio.m_engine.m_audio.m_engine->addSoundSourceFromFile(AUDIO_PATH "noise.ogg", irrklang::ESM_AUTO_DETECT, false); + m_whoosh[x] = nullptr; } - uint64_t seed = SEED; - std::string playname = "La Chienne � Jacques"; - if (NETWORK_TEST) { // Test connexion r�seau. - if (!m_conn.Init()) { - if (!m_conn.Connect(SRV_ADDR, playname)) { - // setup jeu en r�seau. - std::cout << "ID re�u du serveur: " << std::to_string(m_conn.getId()) << "!" << std::endl; - std::cout << "Seed re�u du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl; - seed = m_conn.getSeed(); + std::cout << "Jouer en ligne? [o/N] "; + std::cin >> ch; + std::cout << std::endl; + + if (ch == 'o' || ch == 'O') { + char* input = new char[32]; + std::string playname, srvname; + + while (playname.size() < 1) { + std::cout << "Veuillez entrer un nom de joueur: "; + std::cin.ignore(); + std::cin.getline(input, 32); + std::cout << std::endl; + playname = input; + if (playname.size() < 1 || playname.size() > 32) + std::puts("Nom invalide."); } - else std::cout << "Erreur de connexion." << std::endl; + while (srvname.size() < 1) { + std::cout << "Veuillez entrer une adresse de serveur: "; + std::cin.getline(input, 32); + std::cout << std::endl; + srvname = input; + if (srvname.size() < 1 || srvname.size() > 32) + std::puts("Adresse serveur invalide."); + } + delete[] input; + + if (!m_conn.Init()) { + if (!m_conn.Connect(srvname.c_str(), playname)) { + // setup jeu en reseau. + std::cout << "ID recu du serveur: " << std::to_string(m_conn.getId()) << "!" << std::endl; + std::cout << "Seed recu du serveur: " << std::to_string(m_conn.getSeed()) << "!" << std::endl; + m_player = Player(m_conn.getOrigin().position); + + for (auto& [key, player] : m_conn.m_players) + m_players[key] = new RemotePlayer(player); + + seed = m_conn.getSeed(); + m_networkgame = true; + } + else std::cout << "Erreur de connexion." << std::endl; + } + else std::cout << "Erreur de creation de socket." << std::endl; } - else std::cout << "Erreur de cr�ation de socket." << std::endl; - } m_world.SetSeed(seed); // Init Chunks m_world.GetChunks().Reset(nullptr); - - // Gestion de souris. CenterMouse(); HideCursor(); @@ -590,7 +621,9 @@ void Engine::DisplayHud(int timer) { glVertex2f(fPosX, fBarPosY); glEnd(); - // Current HP + //TODO: Associer avec mechanique de vie du joueur + + // Barre HP glColor3f(0.0f * facteurOmbrage, 1.0f * facteurOmbrage, 0.0f * facteurOmbrage); glBegin(GL_QUADS); glVertex2f(fPosX, fBarPosY - fBarHeight); @@ -868,6 +901,7 @@ std::pair Engine::GetScale() const { } int Engine::GetFps(float elapsedTime) const { return 1 / elapsedTime; } + int Engine::GetCountdown(float elapsedTime) { if (m_resetcountdown) { @@ -930,8 +964,8 @@ void Engine::Render(float elapsedTime) { break; default: break; } - m_audio.Update3DAudio(m_player.GetPOV(), m_player.GetDirection(), m_player.GetVelocity()); // Ajustement du positionnement 3D avec les coordonn�es du joueur et - // son vecteur de v�locit� (pour l'effet Doppler) + m_audio.Update3DAudio(m_player.GetPOV(), m_player.GetDirection(), m_player.GetVelocity()); // Ajustement du positionnement 3D avec les coordonnees du joueur et + // son vecteur de velocite (pour l'effet Doppler) pollTime = 0; } @@ -955,10 +989,18 @@ void Engine::Render(float elapsedTime) { m_bullets[x] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection()); break; } - else if (x == MAX_BULLETS - 1) { // S'il y a pas d'espace dans l'array, prendre la place de la premi�re balle de l'array. + else if (x == MAX_BULLETS - 1) { // S'il y a pas d'espace dans l'array, prendre la place de la première balle de l'array. m_bullets[0]->~Bullet(); m_bullets[0] = new Bullet(m_player.GetPOV() + m_player.GetDirection(), m_player.GetDirection()); } + bulletTime = BULLET_TIME; + m_audio.Create3DAudioObj(m_powpow, AUDIO_PATH "pow.wav", m_player.GetPOV(), m_player.GetDirection() * 10, false, .5f); + if (m_flash) { // Coupe le rendering et affiche un frame blanc, pour simuler un flash. + glClearColor(.8f, .8f, .8f, 1.f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT); + glClearColor(0.f, 0.f, 0.f, 1.f); + return; + } } } else if (m_mouseR) @@ -966,7 +1008,7 @@ void Engine::Render(float elapsedTime) { for (int x = 0; x < MAX_BULLETS; ++x) { // Array de bullets en jeu. if (m_bullets[x]) { - for (int b = 0; b < BULLET_UPDATES_PER_FRAME; ++b) + for (int b = 0; b < BULLET_UPDATES_PER_FRAME; ++b) { if (m_bullets[x]->Update(&m_world, elapsedTime, BULLET_UPDATES_PER_FRAME)) { m_bullets[x]->~Bullet(); if (m_whoosh[x]) @@ -978,13 +1020,17 @@ void Engine::Render(float elapsedTime) { else if (!m_whoosh[x]) { m_whoosh[x] = m_audio.Create3DAudioObj(m_whoosh[x], AUDIO_PATH "noise.wav", m_bullets[x]->getPos(), m_bullets[x]->getVel(), true, (m_bullets[x]->getPos() - m_player.GetPosition()).Length()); } - else m_audio.Render3DAudioObj(m_whoosh[x], m_bullets[x]->getPos(), m_bullets[x]->getVel(), 5 - (m_bullets[x]->getPos() - m_player.GetPosition()).Length()); + else { + Vector3f pos = m_bullets[x]->getPos(), vel = m_bullets[x]->getVel(); + m_audio.Render3DAudioObj(m_whoosh[x], pos, vel, 5 - (m_bullets[x]->getPos() - m_player.GetPosition()).Length()); + } + } } } - m_wrenderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas); + m_renderer.RenderWorld(&m_world, m_renderCount, m_player.GetPosition(), m_player.GetDirection(), all, m_shader01, m_textureAtlas); m_world.Update(m_bullets, m_player.GetPosition(), m_blockinfo); - m_wrenderer.UpdateWorld(&m_world, m_player.GetPosition(), m_blockinfo); + m_renderer.UpdateMesh(&m_world, m_player.GetPosition(), m_blockinfo); if (m_isSkybox) m_skybox.Render(skybox); @@ -1005,6 +1051,28 @@ void Engine::Render(float elapsedTime) { fell = false; } + if (m_networkgame) { + static char* buf = new char[BUFFER_LENGTH]; + uint32_t buflen = BUFFER_LENGTH; + netprot::Input input; + //sockaddr_in addr = m_conn.m_srvsockaddr; + + input.direction = m_player.GetDirection(); + input.sid = m_conn.getId(); + input.timestamp = 12345; + input.keys.forward = m_keyW; + input.keys.backward = m_keyS; + input.keys.left = m_keyA; + input.keys.right = m_keyD; + input.keys.jump = m_keySpace; + input.keys.block = m_mouseR; + input.keys.shoot = m_mouseL; + + //netprot::Serialize(&input, &buf, &buflen); + //sendto(m_conn.m_sock_udp, buf, buflen, 0, (sockaddr*)&addr, sizeof(addr)); + + netprot::sendPackTo(m_conn.m_sock_udp, &input, &buf, &buflen, &m_conn.m_srvsockaddr); + } } else if (m_gamestate == GameState::MAIN_MENU || m_gamestate == GameState::OPTIONS) { @@ -1055,7 +1123,7 @@ void Engine::KeyPressEvent(unsigned char key) { break; case 10: // K - Debugging DisplayNotification() m_keyK = true; - m_messageNotification = "notifications systeme peuvent �tre affich�"; + m_messageNotification = "notifications systeme peuvent etre affichees"; break; case 11: // L - Debugging DisplayNotification() m_keyL = true; diff --git a/SQCSim2021/engine.h b/SQCSim2021/engine.h index 85c4e60..888d696 100644 --- a/SQCSim2021/engine.h +++ b/SQCSim2021/engine.h @@ -18,7 +18,8 @@ #include "audio.h" #include "textureatlas.h" #include "connector.h" -#include "worldrenderer.h" +#include "renderer.h" +#include "remoteplayer.h" class Engine : public OpenglContext { public: @@ -65,7 +66,7 @@ private: TextureAtlas m_textureAtlas = TextureAtlas(BTYPE_LAST); World m_world = World(); - WorldRenderer m_wrenderer = WorldRenderer(); + Renderer m_renderer = Renderer(); Texture m_textureCrosshair; Texture m_textureFont; @@ -86,8 +87,10 @@ private: Bullet* m_bullets[MAX_BULLETS]; + std::map m_players; + //Menu - enum class GameState { MAIN_MENU, OPTIONS, QUIT, NEWG, PLAY }; + enum class GameState: uint8_t { MAIN_MENU, OPTIONS, QUIT, NEWG, PLAY }; GameState m_gamestate = GameState::MAIN_MENU; Texture MenuTitleTexture; Texture MenuBGTexture; @@ -134,6 +137,8 @@ private: float m_mousemx = 0; float m_mousemy = 0; + bool m_networkgame = false; + std::string m_messageNotification = ""; }; diff --git a/SQCSim2021/media/audio/whitenoise.ogg b/SQCSim2021/media/audio/whitenoise.ogg new file mode 100644 index 0000000..7443756 Binary files /dev/null and b/SQCSim2021/media/audio/whitenoise.ogg differ diff --git a/SQCSim2021/remoteplayer.cpp b/SQCSim2021/remoteplayer.cpp new file mode 100644 index 0000000..7769ddc --- /dev/null +++ b/SQCSim2021/remoteplayer.cpp @@ -0,0 +1,70 @@ +#include "remoteplayer.h" +#include +#include + + +RemotePlayer::RemotePlayer(netprot::PlayerInfo pinfo) : Player(Vector3f(0, 0, 0), 0, 0), m_pinfo(pinfo), m_aminacc(0.0f), m_animstate(Anim::STILL), m_team_id(0), current(), previous() { + +} + +void RemotePlayer::Init() { + +} + +void RemotePlayer::Feed(const netprot::Output out) { + + current.position = out.position; + current.direction = out.direction; + current.states = out.states; + current.id = out.id; + + //a revoir pour le jump et le shoot en meme temps lorsque les test seront possible + + if (current.position != previous.position) + { + Vector3f positionDelta = current.position - previous.position; + m_position = current.position + positionDelta; + m_direction = current.direction; + + } + + if(current.direction != previous.direction) + { + m_direction = current.direction; + current.direction = current.direction; + } + + if (current.states.shooting) { + //true; + m_animstate = Anim::SHOOTING; + } + else if (current.states.jumping) { + //true; + m_animstate = Anim::JUMPING; + } + else if (current.states.dead) { + //true; + m_animstate = Anim::DEAD; + } + else if(current.states.powerup){ + //true; + m_animstate = Anim::POWERUP; + } + else if (current.states.still) { + //true; + m_animstate = Anim::STILL; + } + else if (current.states.running) { + //true; + m_animstate = Anim::RUNNING; + } + + + previous.direction = current.direction; + previous.position = current.position; + previous.states = current.states; + previous.id = current.id; + + + +} \ No newline at end of file diff --git a/SQCSim2021/remoteplayer.h b/SQCSim2021/remoteplayer.h new file mode 100644 index 0000000..e8fb8a5 --- /dev/null +++ b/SQCSim2021/remoteplayer.h @@ -0,0 +1,26 @@ +#ifndef REMOTEPLAYER_H__ +#define REMOTEPLAYER_H__ +#include "../SQCSim-common/player.h" +#include "../SQCSim-common/netprotocol.h" +#include "define.h" +#include "textureatlas.h" +#include "shader.h" + +class RemotePlayer : public Player { +public: + enum Anim { STILL = 1, RUNNING = 2, JUMPING = 4, SHOOTING = 8, POWERUP = 16, DEAD = 32 }; + + RemotePlayer(netprot::PlayerInfo pinfo); + + void Init(); + void Feed(const netprot::Output out); + +private: + netprot::Output current, previous; + netprot::PlayerInfo m_pinfo; + float m_aminacc; + Anim m_animstate; + uint64_t m_team_id; + +}; +#endif \ No newline at end of file diff --git a/SQCSim2021/worldrenderer.cpp b/SQCSim2021/renderer.cpp similarity index 87% rename from SQCSim2021/worldrenderer.cpp rename to SQCSim2021/renderer.cpp index e4e0333..b4c8f91 100644 --- a/SQCSim2021/worldrenderer.cpp +++ b/SQCSim2021/renderer.cpp @@ -1,13 +1,13 @@ -#include "worldrenderer.h" +#include "renderer.h" -WorldRenderer::WorldRenderer() { +Renderer::Renderer() { m_meshes.Reset(nullptr); } -WorldRenderer::~WorldRenderer() { +Renderer::~Renderer() { } -void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas) { +void Renderer::RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas) const { rendercount = 0; Vector3f angle; Vector3f cursor; @@ -18,7 +18,7 @@ void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& direct.Normalize(); pos.y = 1; - static Vector3 renderManifest[VIEW_DISTANCE * 8]; // Nombre de Chunks maximal à être rendus. + static Vector3 renderManifest[VIEW_DISTANCE * 8]; // Nombre de Chunks maximal � �tre rendus. //for (int dist = VIEW_DISTANCE; dist >= 0; dist -= CHUNK_SIZE_X) { for (int dist = 0; dist <= VIEW_DISTANCE; dist += CHUNK_SIZE_X) { @@ -27,18 +27,18 @@ void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& int echantillons; if (dist > VIEW_DISTANCE * .1f) { - sinus = .00872653549f; // sin(1/2 degré) - cosinus = .99996192306; // cos(1/2 degré) + sinus = .00872653549f; // sin(1/2 degr�) + cosinus = .99996192306; // cos(1/2 degr�) echantillons = 180; } //else {//if (dist > VIEW_DISTANCE * .3f) { - // sinus = .01151891831f; // sin(2/3 degré) - // cosinus = .99993365506; // cos(2/3 degré) + // sinus = .01151891831f; // sin(2/3 degr�) + // cosinus = .99993365506; // cos(2/3 degr�) // echantillons = 120; //} //else if (dist > VIEW_DISTANCE * .2f) { - // sinus = .01745240643; // sin(1 degré) - // cosinus = .99984769515; // cos(1 degré) + // sinus = .01745240643; // sin(1 degr�) + // cosinus = .99984769515; // cos(1 degr�) // echantillons = 90; //} //else if (dist > VIEW_DISTANCE * .1f) { @@ -72,7 +72,7 @@ void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& bool valide = true; unsigned int chx, chy; origin->ChunkAt(cursor)->GetPosition(chx, chy); - for (int index = 0; index < rendercount; ++index) // Permet de vérifier seulement contre celles ajoutées dans la frame, et ne pas avoir à refaire l'array à chaque frame. + for (int index = 0; index < rendercount; ++index) // Permet de v�rifier seulement contre celles ajout�es dans la frame, et ne pas avoir � refaire l'array � chaque frame. if (renderManifest[index].x == chx && renderManifest[index].z == chy) valide = false; @@ -107,7 +107,7 @@ void WorldRenderer::RenderWorld(World* origin, int& rendercount, const Vector3f& glStencilFunc(GL_GREATER, 1, 0xFF); }; -void WorldRenderer::UpdateWorld(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]) { +void Renderer::UpdateMesh(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]) { int cx = player.x; int cy = player.z; static int frameUpdate = 2; @@ -212,3 +212,10 @@ void WorldRenderer::UpdateWorld(World* origin, const Vector3f& player, BlockInfo } } + +void Renderer::RenderPlayer(Player* player, Transformation tran) const { +} + +void Renderer::RenderPlayer(RemotePlayer* rplayer, const Vector3f& player_pos, const Vector3f& player_dir) const { +} + diff --git a/SQCSim2021/renderer.h b/SQCSim2021/renderer.h new file mode 100644 index 0000000..8afdc3b --- /dev/null +++ b/SQCSim2021/renderer.h @@ -0,0 +1,30 @@ +#ifndef RENDERER_H__ +#define RENDERER_H__ +#include +#include +#include "../SQCSim-common/world.h" +#include "../SQCSim-common/transformation.h" +#include "define.h" +#include "mesh.h" +#include "textureatlas.h" +#include "shader.h" +#include "remoteplayer.h" + +class Renderer { +private: + Array2d m_meshes = Array2d(WORLD_SIZE_X, WORLD_SIZE_Y); + + TextureAtlas* m_playertext = nullptr; + Shader* m_playershader = nullptr; + +public: + Renderer(); + ~Renderer(); + + void UpdateMesh(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]); + + void RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas) const; + void RenderPlayer(Player* player, Transformation tran) const; + void RenderPlayer(RemotePlayer* rplayer, const Vector3f& player_pos, const Vector3f& player_dir) const; +}; +#endif \ No newline at end of file diff --git a/SQCSim2021/worldrenderer.h b/SQCSim2021/worldrenderer.h deleted file mode 100644 index 46e6624..0000000 --- a/SQCSim2021/worldrenderer.h +++ /dev/null @@ -1,23 +0,0 @@ -#ifndef WORLDRENDERER_H__ -#define WORLDRENDERER_H__ -#include -#include -#include "../SQCSim-common/world.h" -#include "../SQCSim-common/transformation.h" -#include "define.h" -#include "mesh.h" -#include "textureatlas.h" -#include "shader.h" - -class WorldRenderer { -private: - Array2d m_meshes = Array2d(WORLD_SIZE_X, WORLD_SIZE_Y); - -public: - WorldRenderer(); - ~WorldRenderer(); - - void RenderWorld(World* origin, int& rendercount, const Vector3f& player_pos, const Vector3f& player_dir, Transformation& world, Shader& shader, TextureAtlas& atlas); - void UpdateWorld(World* origin, const Vector3f& player, BlockInfo* blockinfo[BTYPE_LAST]); -}; -#endif \ No newline at end of file