Blitz/Blitz2
3
0
Fork 0
Code Issues Pull Requests Activity

more use of DeclareAllPacket

Browse Source
This commit is contained in:
Simon Pribylski
2024-07-19 20:22:12 +02:00
parent 7abb31c2e1
commit f9f5f60049
6 changed files with 108 additions and 98 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
include/blitz/network/EnetConnexion.h
View File

@@ -1,9 +1,15 @@
#pragma once
#include <Nazara/Network/ENetPeer.hpp>
#include <NazaraUtils/Signal.hpp>
#include <blitz/protocol/PacketSerializer.h>
#include <blitz/protocol/Packets.h>
namespace Nz {
class ENetPeer;
} // namespace Nz
namespace blitz {
namespace network {
@@ -12,11 +18,10 @@ class EnetServer;
#define DeclarePacket(Name, NFlag) \
void Send##Name(const blitz::protocol::data::Name& a_##Name) const { \
m_Peer->Send(0, NFlag, protocol::PacketSerializer::Serialize(protocol::packets::Name(a_##Name))); \
} \
NazaraSignal(On##Name, const blitz::protocol::data::Name&)
#define DeclarePacket(PacketName, ...) \
void Send##PacketName(const blitz::protocol::data::PacketName& a_##PacketName) const; \
\
NazaraSignal(On##PacketName, const blitz::protocol::data::PacketName&);
@@ -26,11 +31,7 @@ class EnetConnexion {
public:
EnetConnexion(Nz::ENetPeer* a_Peer = nullptr);
bool IsConnected() const {
if (!m_Peer)
return false;
return m_Peer->IsConnected();
}
bool IsConnected() const;
DeclareAllPacket()

53
include/blitz/protocol/PacketDeclare.h
View File

@@ -1,19 +1,40 @@
#pragma once
namespace blitz {
namespace protocol {
enum class PacketSender {
/** Sent by clients and server */
Both,
/** Sent by clients to the server */
Client,
/** Sent by server to the clients */
Server,
};
/**
* \def DeclareAllPacket
* \brief Avoids repetitive operations on packets
*/
#define DeclareAllPacket() \
DeclarePacket(PlayerLogin, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(UpdateHealth, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(LoggingSuccess, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerDeath, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerJoin, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerLeave, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerStats, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerList, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(ServerConfig, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(ServerTps, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(UpdateGameState, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(KeepAlive, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(Disconnect, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(ChatMessage, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerPositionAndRotation, Nz::ENetPacketFlag::Reliable); \
DeclarePacket(PlayerShoot, Nz::ENetPacketFlag::Reliable);
DeclarePacket(ChatMessage, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
DeclarePacket(Disconnect, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
DeclarePacket(KeepAlive, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
DeclarePacket(LoggingSuccess, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(PlayerDeath, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(PlayerJoin, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(PlayerLeave, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(PlayerList, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(PlayerLogin, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Client) \
DeclarePacket(PlayerPositionAndRotation, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
DeclarePacket(PlayerShoot, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Both) \
DeclarePacket(PlayerStats, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(ServerConfig, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(ServerTps, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(UpdateGameState, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Server) \
DeclarePacket(UpdateHealth, Nz::ENetPacketFlag::Reliable, blitz::protocol::PacketSender::Client)
} // namespace protocol
} // namespace blitz

34
include/blitz/protocol/Packets.h
View File

@@ -11,37 +11,17 @@ class PacketVisitor;
using PacketID = std::uint8_t;
#define DeclarePacket(PacketName, ...) PacketName,
enum class PacketType : PacketID {
// client --> server
PlayerLogin = 0,
UpdateHealth,
// client <-- server
LoggingSuccess,
PlayerDeath,
PlayerJoin,
PlayerLeave,
PlayerList,
PlayerStats,
ServerConfig,
ServerTps,
UpdateGameState,
// client <--> server
KeepAlive,
Disconnect,
ChatMessage,
PlayerPositionAndRotation,
PlayerShoot,
DeclareAllPacket()
PACKET_COUNT
};
#undef DeclarePacket
class Packet {
@@ -59,7 +39,7 @@ namespace packets {
/**
* \tparam PT The packet type
* \tparam Data The structure holding the data of the packet
* \tparam Data The structure holding the data of the packet (in blitz::protocol::data namespace)
*/
template <PacketType PT, typename Data>
class ConcretePacket : public Packet {
@@ -90,9 +70,9 @@ class ConcretePacket : public Packet {
#ifdef BLITZ_INSTANCIATE_PACKETS
#define DeclarePacket(PacketName, ...) \
using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>; \
template class ConcretePacket<PacketType::PacketName, data::PacketName>
template class ConcretePacket<PacketType::PacketName, data::PacketName>;
#else
#define DeclarePacket(PacketName, ...) using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>
#define DeclarePacket(PacketName, ...) using PacketName = ConcretePacket<PacketType::PacketName, data::PacketName>;
#endif
DeclareAllPacket()

18
src/blitz/network/EnetConnexion.cpp
View File

@@ -1,5 +1,6 @@
#include <blitz/network/EnetConnexion.h>
#include <Nazara/Network/ENetPeer.hpp>
#include <blitz/protocol/PacketSerializer.h>
#include <blitz/protocol/PacketVisitor.h>
@@ -20,12 +21,14 @@ class PacketDispatcher : public protocol::PacketVisitor {
public:
PacketDispatcher(EnetConnexion& a_Connexion) : m_Connexion(a_Connexion) {}
DeclareAllPacket();
DeclareAllPacket()
private:
EnetConnexion& m_Connexion;
};
#undef DeclarePacket
@@ -36,6 +39,12 @@ void EnetConnexion::SetPeer(Nz::ENetPeer* a_Peer) {
m_Peer = a_Peer;
}
bool EnetConnexion::IsConnected() const {
if (!m_Peer)
return false;
return m_Peer->IsConnected();
}
void EnetConnexion::Recieve(Nz::ByteArray& a_Data) {
auto packet = protocol::PacketSerializer::Deserialize(a_Data);
if (!packet)
@@ -44,5 +53,12 @@ void EnetConnexion::Recieve(Nz::ByteArray& a_Data) {
dispatcher.Check(*packet.get());
}
#define DeclarePacket(Name, NFlag, ...) \
void EnetConnexion::Send##Name(const blitz::protocol::data::Name& a_##Name) const { \
m_Peer->Send(0, NFlag, protocol::PacketSerializer::Serialize(protocol::packets::Name(a_##Name))); \
}
DeclareAllPacket()
} // namespace network
} // namespace blitz

21
src/blitz/protocol/PacketFactory.cpp
View File

@@ -9,23 +9,12 @@ namespace PacketFactory {
using PacketCreator = std::function<std::unique_ptr<Packet>()>;
#define DeclarePacket(PacketName, ...) std::make_unique<packets::PacketName>(),
static const std::array<std::unique_ptr<Packet>, static_cast<std::size_t>(PacketType::PACKET_COUNT)> Packets = {
std::make_unique<packets::PlayerLogin>(),
std::make_unique<packets::UpdateHealth>(),
std::make_unique<packets::LoggingSuccess>(),
std::make_unique<packets::PlayerDeath>(),
std::make_unique<packets::PlayerJoin>(),
std::make_unique<packets::PlayerLeave>(),
std::make_unique<packets::PlayerList>(),
std::make_unique<packets::PlayerStats>(),
std::make_unique<packets::ServerConfig>(),
std::make_unique<packets::ServerTps>(),
std::make_unique<packets::UpdateGameState>(),
std::make_unique<packets::KeepAlive>(),
std::make_unique<packets::Disconnect>(),
std::make_unique<packets::ChatMessage>(),
std::make_unique<packets::PlayerPositionAndRotation>(),
std::make_unique<packets::PlayerShoot>(),
DeclareAllPacket()
};
const std::unique_ptr<Packet>& CreateReadOnlyPacket(PacketType a_Type) {

39
src/blitz/protocol/PacketSerializer.cpp
View File

@@ -11,29 +11,16 @@ namespace protocol {
namespace PacketSerializer {
#define VisitSerialize(ClassName) \
void Visit(const ClassName& a_Packet) override { \
#define DeclarePacket(PacketName, ...) \
void Visit(const packets::PacketName& a_Packet) override { \
const auto& packetData = a_Packet.m_Data; \
SerializePacketData(packetData); \
} \
\
void SerializePacketData(const ClassName::PacketDataType& a_Packet)
#define VisitDeserialize(ClassName) \
void Visit(const ClassName& a_Packet) override { \
auto packetPtr = PacketFactory::CreatePacket<ClassName>(); \
auto& packetData = packetPtr->m_Data; \
\
DeserializePacketData(packetData); \
\
m_Packet = std::move(packetPtr); \
} \
\
void DeserializePacketData(ClassName::PacketDataType& a_Packet)
void SerializePacketData(const packets::PacketName::PacketDataType& a_Packet);
#define DeclarePacket(PacketName, ...) \
VisitSerialize(packets::PacketName)
class Serializer : public PacketVisitor {
private:
@@ -51,8 +38,24 @@ class Serializer : public PacketVisitor {
};
#undef DeclarePacket
#define DeclarePacket(PacketName, ...) \
VisitDeserialize(packets::PacketName)
void Visit(const packets::PacketName& a_Packet) override { \
auto packetPtr = PacketFactory::CreatePacket<packets::PacketName>(); \
auto& packetData = packetPtr->m_Data; \
\
DeserializePacketData(packetData); \
\
m_Packet = std::move(packetPtr); \
} \
\
void DeserializePacketData(packets::PacketName::PacketDataType& a_Packet);
class Deserializer : public PacketVisitor {
private: