GameNetworkingSockets Socket Implementation (78f049ae) · Commits · gamedev / age / libraries

net/CMakeLists.txt

+6 −2

Original line number	Diff line number	Diff line
		set(THIS_TARGET_NAME net)

		file(GLOB "${THIS_TARGET_NAME}_HPP" "./include/${THIS_TARGET_NAME}/*.hpp")
		file(GLOB "${THIS_TARGET_NAME}_CPP" "./src/*.cpp")
		file(GLOB_RECURSE "${THIS_TARGET_NAME}_HPP" "./include/${THIS_TARGET_NAME}/*.hpp")
		file(GLOB_RECURSE "${THIS_TARGET_NAME}_CPP" "./src/*.cpp")

		add_library(${THIS_TARGET_NAME}
		"${${THIS_TARGET_NAME}_HPP}"
		"${${THIS_TARGET_NAME}_CPP}"
		)

		# Find and link GameNetworkingSockets
		find_package(GameNetworkingSockets CONFIG REQUIRED)
		target_link_libraries(${THIS_TARGET_NAME} PUBLIC GameNetworkingSockets::GameNetworkingSockets)
		No newline at end of file

net/include/net/network_types.hpp

+42 −41

Original line number	Diff line number	Diff line
		#pragma once NETWORK_TYPES_HPP
		#pragma once
		#include <cstdint>
		#include <span>

		typedef uint32_t PeerId;
		namespace net
		{
		typedef uint32_t ConnectionId;

		struct NetworkMessage
		{
		PeerId sender;
		std::span<uint8_t> data;
		int length;
		ConnectionId sender;
		std::vector<uint8_t> data;
		int channel;
		};

		enum SocketMode
		enum class SocketMode : uint8_t
		{
		SERVER,
		CLIENT,
		NONE
		};

		enum SendResult
		enum class SendResult : uint8_t
		{
		SUCCESS, // Only queued, not yet sent
		NOT_CONNECTED,
		@@ -28,22 +28,23 @@ enum SendResult
		PEER_NOT_FOUND
		};

		enum ReliabilityMode
		enum class ReliabilityMode : uint8_t
		{
		UNRELIABLE,
		RELIABLE
		};

		enum OrderingMode
		enum class OrderingMode : uint8_t
		{
		UNORDERED,
		ORDERED
		};

		enum ConnectionStatus
		enum class ConnectionStatus : uint8_t
		{
		DISCONNECTED,
		CONNECTING,
		CONNECTED,
		DISCONNECTING
		};
		}

net/include/net/socket.hpp

deleted100644 → 0

+0 −36

Original line number	Diff line number	Diff line
		#pragma once SOCKET_HPP
		#include <functional>
		#include <string>
		#include <net/network_types.hpp>

		struct ISocket
		{
		virtual ~ISocket() = 0;

		virtual bool start_server(int port, int max_connections) = 0;
		virtual bool start_client(std::string address, int port) = 0;
		virtual void server_disconnect_peer(PeerId peer) = 0;
		virtual void shutdown() = 0;

		virtual ConnectionStatus get_status() = 0;
		virtual SocketMode get_mode() = 0;
		virtual std::vector<PeerId> get_connected_peers() = 0;

		// Messaging
		virtual SendResult send(PeerId peer, std::span<const uint8_t> data, int length,
		ReliabilityMode reliability = UNRELIABLE,
		OrderingMode ordering = UNORDERED,
		int channel = 0) = 0;

		// Read a single message from some buffered queue (built in Update)
		virtual NetworkMessage* receive() = 0;

		std::function<void()> on_connected;
		std::function<void()> on_disconnected;
		std::function<void(PeerId)> on_peer_connected;
		std::function<void(PeerId)> on_peer_disconnected;

		// Update the socket, process incoming, call at least once per frame
		virtual void update() = 0;
		virtual int get_max_message_size() = 0;
		};

net/include/net/socket/gns_socket.hpp

0 → 100644

+74 −0

Original line number	Diff line number	Diff line
		#pragma once
		// This file uses the GameNetworkingSockets library, developed by Valve https://github.com/ValveSoftware/GameNetworkingSockets
		// Can be installed via vcpkg
		#include <GameNetworkingSockets/steam/steamnetworkingsockets.h>
		#include <GameNetworkingSockets/steam/isteamnetworkingutils.h>

		#include <net/socket/socket.hpp>
		#include <mutex>
		#include <queue>

		namespace net
		{

		struct GNSSocket final : public ISocket
		{
		GNSSocket();
		~GNSSocket() override;

		bool start_server(int port, int max_connections) override;
		bool start_client(std::string address, int port) override;
		void server_disconnect_peer(ConnectionId peer) override;
		void shutdown() override;

		ConnectionStatus get_status() override;
		SocketMode get_mode() override;
		std::vector<ConnectionId> get_connected_peers() override;

		SendResult send(ConnectionId peer, std::span<const uint8_t> data,
		ReliabilityMode reliability = ReliabilityMode::UNRELIABLE,
		OrderingMode ordering = OrderingMode::UNORDERED,
		int channel = 0) override;

		NetworkMessage* receive() override;

		// Update the socket, process incoming, call at least once per frame
		void update() override;
		int get_max_message_size() override;

		private:
		void on_connection_status_changed(SteamNetConnectionStatusChangedCallback_t* pInfo);
		static void static_connection_status_changed(SteamNetConnectionStatusChangedCallback_t* pInfo); // Static callback forwarder
		static GNSSocket* static_callback_instance;

		void handle_connection_established(HSteamNetConnection connection);
		void handle_connection_closed(HSteamNetConnection connection);
		void handle_client_connected();
		void handle_new_peer_connection(HSteamNetConnection connection);

		void process_incoming_messages();

		HSteamNetConnection get_connection(ConnectionId peer);
		ConnectionId generate_peer_id();

		static int get_send_flags(ReliabilityMode reliability, OrderingMode ordering);

		static constexpr ConnectionId SERVER_PEER_ID = 0;
		ISteamNetworkingSockets* m_interface;
		HSteamListenSocket m_listen_socket;
		HSteamNetPollGroup m_poll_group;

		SocketMode m_mode;
		ConnectionStatus m_status;
		int m_port;
		int m_max_connections;

		std::unordered_map<ConnectionId, HSteamNetConnection> m_peer_to_connection;
		std::unordered_map<HSteamNetConnection, ConnectionId> m_connection_to_peer;
		ConnectionId m_next_peer_id = 1;

		std::queue<std::unique_ptr<NetworkMessage>> m_message_queue;

		std::unique_ptr<NetworkMessage> m_current_message;
		};
		}

net/include/net/socket/socket.hpp

0 → 100644

+39 −0

Original line number	Diff line number	Diff line
		#pragma once
		#include <functional>
		#include <string>
		#include <span>
		#include <vector>
		#include <net/network_types.hpp>

		namespace net
		{
		struct ISocket
		{
		virtual ~ISocket() = default;

		virtual bool start_server(int port, int max_connections) = 0;
		virtual bool start_client(std::string address, int port) = 0;
		virtual void server_disconnect_peer(ConnectionId peer) = 0;
		virtual void shutdown() = 0;

		virtual ConnectionStatus get_status() = 0;
		virtual SocketMode get_mode() = 0;
		virtual std::vector<ConnectionId> get_connected_peers() = 0;

		virtual SendResult send(ConnectionId peer, std::span<const uint8_t> data,
		ReliabilityMode reliability = ReliabilityMode::UNRELIABLE,
		OrderingMode ordering = OrderingMode::UNORDERED,
		int channel = 0) = 0;

		virtual NetworkMessage* receive() = 0;

		std::function<void()> on_connected;
		std::function<void()> on_disconnected;
		std::function<void(ConnectionId)> on_peer_connected;
		std::function<void(ConnectionId)> on_peer_disconnected;

		// Update the socket, process incoming, call at least once per frame
		virtual void update() = 0;
		virtual int get_max_message_size() = 0;
		};
		}