Blitz/Blitz3
3
0
Fork 0
generated from Persson-dev/Godot-Xmake
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

unreliable packets
All checks were successful
Linux arm64 / Build (pull_request) Successful in 1m37s
Details

Browse Source
This commit is contained in:
Simon Pribylski
2024-08-20 19:27:20 +02:00
parent f557d0dd2d
commit 03b6e577ea
5 changed files with 144 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

57
src/blitz/godot/NetworkInterface.cpp
View File

@@ -1,21 +1,37 @@
#include <blitz/godot/NetworkInterface.h>
#include <blitz/protocol/PacketFactory.h>
#include <blitz/protocol/PacketSender.h>
#include <blitz/protocol/PacketSerializer.h>
#include <blitz/protocol/PacketVisitor.h>
#include <godot_cpp/classes/e_net_multiplayer_peer.hpp>
#include <godot_cpp/classes/multiplayer_api.hpp>
#include <godot_cpp/classes/packed_scene.hpp>
#include <godot_cpp/classes/resource_loader.hpp>
#include <godot_cpp/variant/utility_functions.hpp>
namespace blitz {
#define RPC_CONFIG(functionName, rpc_mode, transfer_mode, call_local, channel) \
{ \
Dictionary config; \
config["rpc_mode"] = rpc_mode; \
config["transfer_mode"] = transfer_mode; \
config["call_local"] = call_local; \
config["channel"] = channel; \
rpc_config(functionName, config); \
}
static const char ServerScenePath[] = "res://Scenes/Network/server.tscn";
using namespace godot;
void NetworkInterface::_bind_methods() {
ClassDB::bind_method(D_METHOD("RecievePacketDataReliable", "a_PacketData"), &NetworkInterface::RecievePacketDataReliable);
ClassDB::bind_method(D_METHOD("RecievePacketDataUnreliable", "a_PacketData"), &NetworkInterface::RecievePacketDataUnreliable);
ClassDB::bind_method(
D_METHOD("RecievePacketDataUnreliableOrdered", "a_PacketData"), &NetworkInterface::RecievePacketDataUnreliableOrdered);
// server
ADD_SIGNAL(MethodInfo("player_connected", PropertyInfo(Variant::INT, "peer_id")));
@@ -33,13 +49,10 @@ NetworkInterface::NetworkInterface() {}
NetworkInterface::~NetworkInterface() {}
void NetworkInterface::_ready() {
// TODO: unreliable
Dictionary config;
config["rpc_mode"] = MultiplayerAPI::RPC_MODE_ANY_PEER;
config["transfer_mode"] = MultiplayerPeer::TRANSFER_MODE_RELIABLE;
config["call_local"] = true;
config["channel"] = 0;
rpc_config("RecievePacketDataReliable", config);
RPC_CONFIG("RecievePacketDataReliable", MultiplayerAPI::RPC_MODE_ANY_PEER, MultiplayerPeer::TRANSFER_MODE_RELIABLE, true, 0);
RPC_CONFIG("RecievePacketDataUnreliable", MultiplayerAPI::RPC_MODE_ANY_PEER, MultiplayerPeer::TRANSFER_MODE_UNRELIABLE, true, 1);
RPC_CONFIG("RecievePacketDataUnreliableOrdered", MultiplayerAPI::RPC_MODE_ANY_PEER,
MultiplayerPeer::TRANSFER_MODE_UNRELIABLE_ORDERED, true, 2);
get_multiplayer()->connect("peer_connected", callable_mp(this, &NetworkInterface::OnPlayerConnected));
get_multiplayer()->connect("peer_disconnected", callable_mp(this, &NetworkInterface::OnPlayerDisconnected));
@@ -49,13 +62,13 @@ void NetworkInterface::_ready() {
}
void NetworkInterface::BroadcastPacket(const protocol::Packet& a_Packet) {
PackedByteArray byteArray = protocol::PacketSerializer::Serialize(a_Packet);
rpc("RecievePacketDataReliable", byteArray);
protocol::PacketBroadcaster packetBroadcaster(*this);
packetBroadcaster.BroadcastPacket(a_Packet);
}
void NetworkInterface::SendPacket(PeerID a_Peer, const protocol::Packet& a_Packet) {
PackedByteArray byteArray = protocol::PacketSerializer::Serialize(a_Packet);
rpc_id(a_Peer, "RecievePacketDataReliable", byteArray);
protocol::PacketSender packetSender(a_Peer, *this);
packetSender.SendPacket(a_Packet);
}
void NetworkInterface::RecievePacketDataReliable(godot::PackedByteArray a_PacketData) {
@@ -66,9 +79,27 @@ void NetworkInterface::RecievePacketDataReliable(godot::PackedByteArray a_Packet
}
}
void NetworkInterface::RecievePacketDataUnreliable(godot::PackedByteArray a_PacketData) {
// we have to copy the function body in order to preserve the remote sender id
auto packet = protocol::PacketSerializer::Deserialize(a_PacketData);
if (packet) {
packet->m_Sender = get_multiplayer()->get_remote_sender_id();
Dispatch(*packet);
}
}
void NetworkInterface::RecievePacketDataUnreliableOrdered(godot::PackedByteArray a_PacketData) {
// we have to copy the function body in order to preserve the remote sender id
auto packet = protocol::PacketSerializer::Deserialize(a_PacketData);
if (packet) {
packet->m_Sender = get_multiplayer()->get_remote_sender_id();
Dispatch(*packet);
}
}
Error NetworkInterface::JoinGame(const String& a_Address, uint16_t a_Port) {
auto* peer = memnew(ENetMultiplayerPeer);
Error error = peer->create_client(a_Address, a_Port);
Error error = peer->create_client(a_Address, a_Port, 3);
if (error) {
OnConnectFail();
return error;
@@ -80,7 +111,7 @@ Error NetworkInterface::JoinGame(const String& a_Address, uint16_t a_Port) {
Error NetworkInterface::CreateGame(uint16_t a_Port, bool a_Dedicated) {
auto* peer = memnew(ENetMultiplayerPeer);
Error error = peer->create_server(a_Port);
Error error = peer->create_server(a_Port, 50, 3);
if (error)
return error;

39
src/blitz/protocol/PacketSender.cpp Normal file
View File

@@ -0,0 +1,39 @@
#include <blitz/protocol/PacketSender.h>
#include <blitz/godot/NetworkInterface.h>
#include <blitz/protocol/PacketSerializer.h>
namespace blitz {
namespace protocol {
///////////////////////
/* PacketBroadcaster */
///////////////////////
#define DeclarePacket(PacketName, Reliability, ...) \
void PacketBroadcaster::Visit(const protocol::packets::PacketName& a_Packet) { \
m_NetworkInterface.rpc("RecievePacketData" #Reliability, protocol::PacketSerializer::Serialize(a_Packet)); \
}
DeclareAllPacket()
#undef DeclarePacket
//////////////////
/* PacketSender */
//////////////////
#define DeclarePacket(PacketName, Reliability, ...) \
void PacketSender::Visit(const protocol::packets::PacketName& a_Packet) { \
m_NetworkInterface.rpc_id(m_PeerId, "RecievePacketData" #Reliability, protocol::PacketSerializer::Serialize(a_Packet)); \
}
DeclareAllPacket()
#undef DeclarePacket
} // namespace protocol
} // namespace blitz