Add high-level multiplayer packet management

Add PacketType tests

Author: Spartan322

src/openvic-simulation/GameManager.cpp

@@ -1,6 +1,10 @@
 #include "GameManager.hpp"
 
 #include <chrono>
+#include <string_view>
+
+#include "openvic-simulation/multiplayer/ClientManager.hpp"
+#include "openvic-simulation/multiplayer/HostManager.hpp"
 
 using namespace OpenVic;
 
@@ -125,6 +129,17 @@ bool GameManager::update_clock() {
 	return instance_manager->update_clock();
 }
 
+void GameManager::create_client() {
+	client_manager = memory::make_unique<ClientManager>(this);
+}
+
+void GameManager::create_host(std::string_view session_name) {
+	host_manager = memory::make_unique<HostManager>(this);
+	if (!session_name.empty()) {
+		host_manager->get_host_session().set_game_name(memory::string { session_name });
+	}
+}
+
 uint64_t GameManager::get_elapsed_microseconds() {
 	return get_elapsed_usec_time_callback();
 }

src/openvic-simulation/GameManager.hpp

@@ -2,17 +2,23 @@
 
 #include <optional>
 #include <span>
+#include <string_view>
 
 #include "openvic-simulation/DefinitionManager.hpp"
 #include "openvic-simulation/InstanceManager.hpp"
 #include "openvic-simulation/dataloader/ModManager.hpp"
 #include "openvic-simulation/dataloader/Dataloader.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/gen/commit_info.gen.hpp"
+#include "openvic-simulation/multiplayer/ClientManager.hpp"
+#include "openvic-simulation/multiplayer/HostManager.hpp"
 
 #include <function2/function2.hpp>
 
 namespace OpenVic {
+	struct HostManager;
+	struct ClientManager;
+
 	struct GameManager {
 		using elapsed_time_getter_func_t = fu2::function_base<true, true, fu2::capacity_none, false, false, uint64_t() const>;
 
@@ -30,6 +36,9 @@ namespace OpenVic {
 		bool PROPERTY_CUSTOM_PREFIX(definitions_loaded, are);
 		bool PROPERTY_CUSTOM_PREFIX(mod_descriptors_loaded, are);
 
+		memory::unique_ptr<HostManager> host_manager;
+		memory::unique_ptr<ClientManager> client_manager;
+
 	public:
 		GameManager(
 			InstanceManager::gamestate_updated_func_t new_gamestate_updated_callback,
@@ -45,6 +54,22 @@ namespace OpenVic {
 			return instance_manager ? &*instance_manager : nullptr;
 		}
 
+		inline HostManager* get_host_manager() {
+			return host_manager.get();
+		}
+
+		inline HostManager const* get_host_manager() const {
+			return host_manager.get();
+		}
+
+		inline ClientManager* get_client_manager() {
+			return client_manager.get();
+		}
+
+		inline ClientManager const* get_client_manager() const {
+			return client_manager.get();
+		}
+
 		bool set_roots(Dataloader::path_span_t roots, Dataloader::path_span_t replace_paths);
 
 		bool load_mod_descriptors(std::span<const memory::string> descriptors);
@@ -57,6 +82,9 @@ namespace OpenVic {
 
 		bool update_clock();
 
+		void create_client();
+		void create_host(std::string_view session_name = "");
+
 		static constexpr std::string_view get_commit_hash() {
 			return SIM_COMMIT_HASH;
 		}

src/openvic-simulation/multiplayer/BaseMultiplayerManager.cpp

@@ -0,0 +1,23 @@
+
+#include "BaseMultiplayerManager.hpp"
+
+#include <any>
+
+#include "openvic-simulation/multiplayer/PacketType.hpp"
+#include "openvic-simulation/utility/ErrorMacros.hpp"
+
+using namespace OpenVic;
+
+BaseMultiplayerManager::BaseMultiplayerManager(GameManager* game_manager) : game_manager(game_manager) {
+	packet_cache.reserve_power(15);
+}
+
+bool BaseMultiplayerManager::broadcast_packet(PacketType const& type, std::any const& argument) {
+	OV_ERR_FAIL_COND_V(!PacketType::is_valid_type(type), false);
+	return true;
+}
+
+bool BaseMultiplayerManager::send_packet(client_id_type client_id, PacketType const& type, std::any const& argument) {
+	OV_ERR_FAIL_COND_V(!PacketType::is_valid_type(type), false);
+	return true;
+}

src/openvic-simulation/multiplayer/BaseMultiplayerManager.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <any>
+#include <cstdint>
+
+#include "openvic-simulation/multiplayer/HostSession.hpp"
+#include "openvic-simulation/multiplayer/PacketType.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/ReliableUdpClient.hpp"
+#include "openvic-simulation/types/RingBuffer.hpp"
+#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/utility/Getters.hpp"
+
+namespace OpenVic {
+	struct GameManager;
+
+	struct BaseMultiplayerManager {
+		BaseMultiplayerManager(GameManager* game_manager = nullptr);
+
+		using client_id_type = uint64_t;
+		using sequence_type = ReliableUdpClient::sequence_type;
+
+		virtual bool broadcast_packet(PacketType const& type, std::any const& argument);
+		virtual bool send_packet(client_id_type client_id, PacketType const& type, std::any const& argument);
+		virtual int64_t poll() = 0;
+
+		enum class ConnectionType : uint8_t { HOST, CLIENT };
+
+		virtual ConnectionType get_connection_type() const = 0;
+
+		template<typename T>
+		T* cast_as() {
+			if (get_connection_type() == T::type_tag) {
+				return static_cast<T*>(this);
+			}
+			return nullptr;
+		}
+
+		PacketSpan get_last_raw_packet() {
+			return last_raw_packet;
+		}
+
+	protected:
+		bool PROPERTY_ACCESS(in_lobby, protected, false);
+		GameManager* PROPERTY_PTR_ACCESS(game_manager, protected);
+		HostSession PROPERTY_ACCESS(host_session, protected);
+
+		RingBuffer<uint8_t> packet_cache;
+
+		struct PacketCacheIndex {
+			decltype(packet_cache)::const_iterator begin;
+			decltype(packet_cache)::const_iterator end;
+			constexpr bool is_valid() const {
+				return begin != end;
+			}
+		};
+
+		memory::vector<uint8_t> last_raw_packet;
+
+		friend bool PacketTypes::send_raw_packet_process_callback( //
+			BaseMultiplayerManager* multiplayer_manager, PacketSpan packet
+		);
+	};
+}

src/openvic-simulation/multiplayer/ClientManager.cpp

@@ -0,0 +1,156 @@
+
+#include "ClientManager.hpp"
+
+#include <cstdio>
+#include <filesystem>
+#include <string_view>
+#include <system_error>
+
+#include "openvic-simulation/GameManager.hpp"
+#include "openvic-simulation/multiplayer/PacketType.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/HostnameAddress.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/NetworkError.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/NetworkSocket.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/PacketBuilder.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/ReliableUdpClient.hpp"
+#include "openvic-simulation/utility/Containers.hpp"
+#include "openvic-simulation/utility/ErrorMacros.hpp"
+
+using namespace OpenVic;
+
+bool ClientManager::connect_to(HostnameAddress const& address, NetworkSocket::port_type port) {
+	NetworkError err = client.connect_to(address.resolved_address(), port);
+	OV_ERR_FAIL_COND_V(err != NetworkError::OK, false);
+	PacketBuilder builder;
+	builder.put_back<uint8_t>(1);
+	return client.set_packet(builder) == NetworkError::OK;
+}
+
+template<PacketType const& type>
+bool ClientManager::_send_packet_to_host(auto const& argument) {
+	PacketBuilder builder;
+	builder.put_back(type.packet_id);
+	if (!type.create_packet(this, argument, builder)) {
+		return false;
+	}
+
+	if (!add_packet_to_cache(builder)) {
+		return false;
+	}
+
+	client.set_packet(builder);
+	return true;
+}
+
+bool ClientManager::broadcast_packet(PacketType const& type, std::any const& argument) {
+	if (!BaseMultiplayerManager::broadcast_packet(type, argument)) {
+		return false;
+	}
+
+	OV_ERR_FAIL_COND_V(!type.can_client_send, false);
+	return _send_packet_to_host<PacketTypes::broadcast_packet>(BroadcastData { type.packet_id, argument });
+}
+
+bool ClientManager::send_packet(client_id_type client_id, PacketType const& type, std::any const& argument) {
+	if (!BaseMultiplayerManager::send_packet(client_id, type, argument)) {
+		return false;
+	}
+
+	OV_ERR_FAIL_COND_V(!type.can_client_send, false);
+	return _send_packet_to_host<PacketTypes::retransmit_packet>(RetransmitData { client_id, type.packet_id, argument });
+}
+
+int64_t ClientManager::poll() {
+	int64_t result = client.available_packets();
+	if (result < 1) {
+		return result;
+	}
+
+	PacketSpan span = client.packet_span();
+	if (client_id == INVALID_CLIENT_ID) {
+		OV_ERR_FAIL_COND_V(client.get_current_sequence_value() != 0, -1);
+		client_id = span.read<decltype(client_id)>();
+		OV_ERR_FAIL_COND_V(client_id == INVALID_CLIENT_ID, -1);
+		return poll();
+	}
+
+	decltype(PacketType::packet_id) packet_id = span.read<decltype(packet_id)>();
+	OV_ERR_FAIL_COND_V(!PacketType::is_valid_type(packet_id), -1);
+
+	PacketType const& packet_type = PacketType::get_type_by_id(packet_id);
+	if (!packet_type.process_packet(this, span)) {
+		// TODO: packet processing failed
+		return -1;
+	}
+	// TODO: packet was processed
+
+	return result;
+}
+
+bool ClientManager::connect_to_resource_server(std::optional<NetworkSocket::port_type> port) {
+	if (is_running_as_host()) {
+		return true;
+	}
+
+	NetworkError err = resource_client.connect_to(client.get_peer_ip(), port.value_or(client.get_peer_port() + 1));
+	OV_ERR_FAIL_COND_V(err != NetworkError::OK, false);
+	return true;
+}
+
+void ClientManager::poll_resource_download() {
+	if (is_running_as_host()) {
+		return;
+	}
+
+	if (resource_client.poll() != NetworkError::OK || resource_client.get_status() != TcpPacketStream::Status::CONNECTED) {
+		return;
+	}
+
+	PacketBuffer buffer = resource_client.packet_buffer(sizeof(size_t));
+	size_t buffer_size = buffer.read<size_t>();
+	buffer.clear();
+	buffer.resize(buffer_size);
+	resource_client.get_data(buffer);
+	std::string_view str = buffer.read<std::string_view>();
+	std::filesystem::path path = str;
+	size_t index = buffer.index();
+	std::span<const uint8_t> data { &buffer.data()[index], buffer.size() - index };
+
+	// TODO: separate file writing into a separate thread?
+	std::error_code ec;
+
+	OV_ERR_FAIL_COND(!std::filesystem::create_directories(path.parent_path(), ec) || !ec);
+
+	{
+		std::FILE* file = std::fopen(path.c_str(), "w");
+		OV_ERR_FAIL_COND(file == nullptr);
+
+		size_t write_count = std::fwrite(data.data(), sizeof(uint8_t), data.size(), file);
+		std::fclose(file);
+		OV_ERR_FAIL_COND(write_count != buffer_size);
+	}
+}
+
+bool ClientManager::is_running_as_host() const {
+	return game_manager->get_host_manager() != nullptr;
+}
+
+bool ClientManager::add_packet_to_cache(std::span<uint8_t> bytes) {
+	OV_ERR_FAIL_COND_V(bytes.size_bytes() > ReliableUdpClient::MAX_PACKET_SIZE, false);
+	decltype(packet_cache)::iterator begin = packet_cache.append(bytes.data(), bytes.size_bytes());
+	decltype(packet_cache)::iterator end = packet_cache.end();
+	OV_ERR_FAIL_COND_V(begin == end, false);
+	return sequence_to_index.try_emplace(client.get_next_sequence_value(), PacketCacheIndex { begin, end }).second;
+}
+
+memory::vector<uint8_t> ClientManager::get_packet_cache(sequence_type sequence_value) {
+	decltype(sequence_to_index)::iterator it = sequence_to_index.find(sequence_value);
+	OV_ERR_FAIL_COND_V(it == sequence_to_index.end(), {});
+	return { it.value().begin, it.value().end };
+}
+
+void ClientManager::remove_from_cache(sequence_type sequence_value) {
+	decltype(sequence_to_index)::iterator it = sequence_to_index.find(sequence_value);
+	OV_ERR_FAIL_COND(it == sequence_to_index.end());
+	sequence_to_index.unordered_erase(it);
+}

src/openvic-simulation/multiplayer/ClientManager.hpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <limits>
+#include <optional>
+
+#include "openvic-simulation/multiplayer/BaseMultiplayerManager.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/HostnameAddress.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/NetworkSocket.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/ReliableUdpClient.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/TcpPacketStream.hpp"
+#include "openvic-simulation/utility/Containers.hpp"
+
+namespace OpenVic {
+	struct GameManager;
+
+	struct ClientManager final : BaseMultiplayerManager {
+		using BaseMultiplayerManager::BaseMultiplayerManager;
+
+		bool connect_to(HostnameAddress const& address, NetworkSocket::port_type port);
+
+		bool broadcast_packet(PacketType const& type, std::any const& argument) override;
+		bool send_packet(client_id_type client_id, PacketType const& type, std::any const& argument) override;
+		int64_t poll() override;
+
+		bool connect_to_resource_server(std::optional<NetworkSocket::port_type> port = std::nullopt);
+		void poll_resource_download();
+
+		bool is_running_as_host() const;
+
+		static constexpr ConnectionType type_tag = ConnectionType::CLIENT;
+		inline constexpr ConnectionType get_connection_type() const override {
+			return type_tag;
+		}
+
+		static constexpr client_id_type INVALID_CLIENT_ID = std::numeric_limits<client_id_type>::max();
+
+	private:
+		ReliableUdpClient PROPERTY_REF(client);
+		TcpPacketStream resource_client;
+		client_id_type PROPERTY(client_id, INVALID_CLIENT_ID);
+
+		friend bool PacketTypes::update_host_session_process_callback(BaseMultiplayerManager* game_manager, PacketSpan packet);
+
+		ordered_map<sequence_type, PacketCacheIndex> sequence_to_index;
+
+		bool add_packet_to_cache(std::span<uint8_t> bytes);
+		memory::vector<uint8_t> get_packet_cache(sequence_type sequence_value);
+		void remove_from_cache(sequence_type sequence_value);
+
+		template<PacketType const& type>
+		bool _send_packet_to_host(auto const& argument);
+	};
+}