206 lines
6.6 KiB
C++
206 lines
6.6 KiB
C++
#ifndef NETPROTOCOL_H__
|
|
#define NETPROTOCOL_H__
|
|
|
|
#include <string>
|
|
#include "define.h"
|
|
#include "vector3.h"
|
|
|
|
/* Protocole Particulier de Partie a Plusieurs Personnes (PPPPP) */
|
|
|
|
// Packet: packet[0] = PacketType, packet[1..n-1] = {packet}
|
|
|
|
namespace netprot {
|
|
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,
|
|
backward,
|
|
left,
|
|
right,
|
|
jump,
|
|
shoot,
|
|
block;
|
|
};
|
|
|
|
struct States {
|
|
bool jumping,
|
|
shooting,
|
|
hit,
|
|
powerup,
|
|
dead,
|
|
still,
|
|
jumpshot,
|
|
running;
|
|
};
|
|
|
|
struct Input { // cli -> srv UDP ~frame
|
|
Timestamp timestamp;
|
|
uint64_t sid = 0;
|
|
Keys keys; // 0bFBLRJS__ bit-packing de bool.
|
|
Vector3f direction;
|
|
};
|
|
|
|
struct Output { // srv -> cli UDP ~frame
|
|
Timestamp timestamp;
|
|
uint64_t id = 0;
|
|
Vector3f position,
|
|
direction;
|
|
States states; // 0bJSH_____ bit-packing de bool.
|
|
};
|
|
|
|
struct Sync { // srv -> cli TCP ~second
|
|
Timestamp timestamp;
|
|
uint64_t sid = 0;
|
|
uint32_t timer = 0;
|
|
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; // TODD: enum.
|
|
GameInfo() {}
|
|
GameInfo(GameInfo* gam) : seed(gam->seed), countdown(gam->countdown), gameType(gam->gameType) {}
|
|
};
|
|
|
|
struct Chat { // cli <-> srv TCP event
|
|
uint64_t src_id = 0,
|
|
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
|
|
void Serialize(Output* out, char* buf[], uint32_t* buflen); // srv
|
|
void Serialize(Sync* sync, char* buf[], uint32_t* buflen); // srv
|
|
void Serialize(TeamInfo* tinfo, char* buf[], uint32_t* buflen); // cli/srv
|
|
void Serialize(LoginInfo* linfo, char* buf[], uint32_t* buflen); // cli/srv
|
|
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(ErrorLog* errlog, char* buf[], uint32_t* buflen); // srv
|
|
|
|
bool Deserialize(Input* in, char* buf, const uint32_t buflen); // srv
|
|
bool Deserialize(Output* out, char* buf, const uint32_t buflen); // cli
|
|
bool Deserialize(Sync* sync, char* buf, const uint32_t buflen); // cli
|
|
bool Deserialize(TeamInfo* tinfo, char* buf, const uint32_t buflen); // cli/srv
|
|
bool Deserialize(LoginInfo* linfo, char* buf, const uint32_t buflen); // cli/srv
|
|
bool Deserialize(PlayerInfo* pinfo, char* buf, const uint32_t buflen); // cli
|
|
bool Deserialize(GameInfo* ginfo, char* buf, const uint32_t buflen); // cli
|
|
bool Deserialize(Chat* chat, char* buf, const uint32_t buflen); // srv/cli
|
|
bool Deserialize(ErrorLog* errlog, char* buf, const uint32_t buflen); // srv
|
|
|
|
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 <class T> void sendPack(SOCKET sock, T* pack, char** buf, uint32_t* buflen);
|
|
template <class T> void sendPackTo(SOCKET sock, T* pack, char** buf, uint32_t* buflen, sockaddr_in* sockad);
|
|
|
|
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<Packet> recvPacks(SOCKET sock, Buffer* buf);
|
|
|
|
template <class T>
|
|
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 <class T>
|
|
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 <class T>
|
|
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 <class T>
|
|
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
|