Add high-level multiplayer packet management

Add ChatManager
Add PacketType tests
Add ChatManager tests
Add `snitch::game_manager` extern variable
Add `snitch::get_mp_game_managers(size_t)` extern function
Disable `SNITCH_DEFINE_MAIN` for tests/src/main.cpp
Add cross-platform fopen in `OpenVic::utility`

Author: Spartan322

src/openvic-simulation/GameManager.cpp

@@ -1,11 +1,16 @@
 #include "GameManager.hpp"
 
 #include <chrono>
+#include <string_view>
+
+#include "openvic-simulation/multiplayer/ClientManager.hpp"
+#include "openvic-simulation/multiplayer/HostManager.hpp"
 
 #include <cstddef>
 #include <string_view>
 
 #include "openvic-simulation/dataloader/Dataloader.hpp"
+#include "openvic-simulation/utility/Containers.hpp"
 #include "openvic-simulation/utility/Logger.hpp"
 
 using namespace OpenVic;
@@ -230,6 +235,26 @@ bool GameManager::update_clock() {
 	return instance_manager->update_clock();
 }
 
+void GameManager::create_client() {
+	client_manager = memory::make_unique<ClientManager>(this);
+	chat_manager = memory::make_unique<ChatManager>(client_manager.get());
+}
+
+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 });
+	}
+}
+
+void GameManager::delete_client() {
+	client_manager.reset();
+}
+
+void GameManager::delete_host(){
+	host_manager.reset();
+}
+
 uint64_t GameManager::get_elapsed_microseconds() {
 	return get_elapsed_usec_time_callback();
 }

src/openvic-simulation/GameManager.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <optional>
+#include <span>
 #include <string_view>
 
 #include "openvic-simulation/DefinitionManager.hpp"
@@ -9,11 +10,17 @@
 #include "openvic-simulation/dataloader/Dataloader.hpp"
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/gen/commit_info.gen.hpp"
+#include "openvic-simulation/multiplayer/ChatManager.hpp"
+#include "openvic-simulation/multiplayer/ClientManager.hpp"
+#include "openvic-simulation/multiplayer/HostManager.hpp"
 #include "openvic-simulation/utility/ForwardableSpan.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>;
 
@@ -31,6 +38,10 @@ 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;
+		memory::unique_ptr<ChatManager> chat_manager;
+
 		bool _get_mod_dependencies(Mod const* mod, memory::vector<Mod const*>& load_list);
 
 	public:
@@ -48,6 +59,30 @@ 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();
+		}
+
+		inline ChatManager* get_chat_manager() {
+			return chat_manager.get();
+		}
+
+		inline ChatManager const* get_chat_manager() const {
+			return chat_manager.get();
+		}
+
 		inline bool set_base_path(Dataloader::path_span_t base_path) {
 			OV_ERR_FAIL_COND_V_MSG(base_path.size() > 1, "more than one dataloader base path provided", false);
 			OV_ERR_FAIL_COND_V_MSG(!dataloader.set_roots(base_path, {}), "failed to set dataloader base path", false);
@@ -70,6 +105,12 @@ namespace OpenVic {
 
 		bool update_clock();
 
+		void create_client();
+		void create_host(std::string_view session_name = "");
+
+		void delete_client();
+		void delete_host();
+
 		static constexpr std::string_view get_commit_hash() {
 			return SIM_COMMIT_HASH;
 		}

src/openvic-simulation/multiplayer/BaseMultiplayerManager.cpp

@@ -0,0 +1,21 @@
+
+#include "BaseMultiplayerManager.hpp"
+
+#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, PacketType::argument_type 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, PacketType::argument_type argument) {
+	OV_ERR_FAIL_COND_V(!PacketType::is_valid_type(type), false);
+	return true;
+}

src/openvic-simulation/multiplayer/BaseMultiplayerManager.hpp

@@ -0,0 +1,74 @@
+#pragma once
+
+#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);
+		virtual ~BaseMultiplayerManager() = default;
+
+		using client_id_type = uint64_t;
+		using sequence_type = ReliableUdpClient::sequence_type;
+
+		static constexpr client_id_type HOST_ID = static_cast<client_id_type>(~0);
+
+		virtual bool broadcast_packet(PacketType const& type, PacketType::argument_type argument);
+		virtual bool send_packet(client_id_type client_id, PacketType const& type, PacketType::argument_type argument);
+		virtual int64_t poll() = 0;
+		virtual void close() = 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;
+		}
+
+		template<typename T>
+		T const* cast_as() const {
+			if (get_connection_type() == T::type_tag) {
+				return static_cast<T const*>(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/ChatManager.cpp

@@ -0,0 +1,125 @@
+
+#include "ChatManager.hpp"
+
+#include <chrono>
+#include <utility>
+
+#include "openvic-simulation/GameManager.hpp"
+#include "openvic-simulation/multiplayer/ClientManager.hpp"
+#include "openvic-simulation/multiplayer/PacketType.hpp"
+#include "openvic-simulation/utility/ErrorMacros.hpp"
+
+using namespace OpenVic;
+
+ChatGroup::ChatGroup(index_t index, memory::vector<BaseMultiplayerManager::client_id_type>&& clients)
+	: index { index }, clients { std::move(clients) } {}
+
+ChatManager::ChatManager(ClientManager* client_manager) : client_manager { client_manager } {}
+
+bool ChatManager::send_private_message(BaseMultiplayerManager::client_id_type to, memory::string&& message) {
+	MessageData data { MessageType::PRIVATE, std::move(message), to };
+
+	ChatMessageLog const& log = log_message(client_manager->get_client_id(), std::move(data));
+	bool was_sent = client_manager->broadcast_packet(PacketTypes::send_chat_message, &log);
+	return was_sent;
+}
+
+bool ChatManager::send_private_message(BaseMultiplayerManager::client_id_type to, std::string_view message) {
+	return send_private_message(to, memory::string { message });
+}
+
+bool ChatManager::send_public_message(memory::string&& message) {
+	MessageData data { MessageType::PUBLIC, std::move(message) };
+
+	ChatMessageLog const& log = log_message(client_manager->get_client_id(), std::move(data));
+	bool was_sent = client_manager->broadcast_packet(PacketTypes::send_chat_message, &log);
+	return was_sent;
+}
+
+bool ChatManager::send_public_message(std::string_view message) {
+	return send_public_message(memory::string { message });
+}
+
+bool ChatManager::send_group_message(ChatGroup const& group, memory::string&& message) {
+	MessageData data { MessageType::GROUP, std::move(message), group.get_index() };
+
+	ChatMessageLog const& log = log_message(client_manager->get_client_id(), std::move(data));
+	bool was_sent = client_manager->broadcast_packet(PacketTypes::send_chat_message, &log);
+	return was_sent;
+}
+
+bool ChatManager::send_group_message(ChatGroup::index_t group_id, memory::string&& message) {
+	OV_ERR_FAIL_INDEX_V(group_id, groups.size(), false);
+	return send_group_message(groups[group_id], std::move(message));
+}
+
+bool ChatManager::send_group_message(ChatGroup const& group, std::string_view message) {
+	return send_group_message(group, memory::string { message });
+}
+
+bool ChatManager::send_group_message(ChatGroup::index_t group_id, std::string_view message) {
+	return send_group_message(group_id, memory::string { message });
+}
+
+ChatMessageLog const& ChatManager::log_message( //
+	BaseMultiplayerManager::client_id_type from, MessageData&& message,
+	std::chrono::time_point<std::chrono::system_clock> timestamp
+) {
+	ChatMessageLog const& log = messages.emplace_back(
+		from, std::move(message), std::chrono::time_point_cast<std::chrono::milliseconds>(timestamp).time_since_epoch().count()
+	);
+	message_logged(log);
+	return log;
+}
+
+ChatMessageLog const* ChatManager::_log_message(ChatMessageLog&& log) {
+	std::chrono::time_point cur = std::chrono::system_clock::now();
+	int64_t current_epoch = std::chrono::time_point_cast<std::chrono::milliseconds>(cur).time_since_epoch().count();
+	OV_ERR_FAIL_COND_V_MSG(log.timestamp > current_epoch, nullptr, "Invalid chat message log, cannot log future timestamps.");
+
+	ChatMessageLog const& moved_log = messages.emplace_back(std::move(log));
+	message_logged(moved_log);
+	return &moved_log;
+}
+
+memory::vector<ChatMessageLog> const& ChatManager::get_message_logs() const {
+	return messages;
+}
+
+void ChatManager::create_group(memory::vector<BaseMultiplayerManager::client_id_type>&& clients) {
+	client_manager->broadcast_packet(PacketTypes::add_chat_group, clients);
+}
+
+void ChatManager::_create_group(memory::vector<BaseMultiplayerManager::client_id_type>&& clients) {
+	groups.push_back({ groups.size(), std::move(clients) });
+	ChatGroup const& last = groups.back();
+	group_created(last);
+}
+
+void ChatManager::set_group(ChatGroup::index_t group_id, memory::vector<BaseMultiplayerManager::client_id_type>&& clients) {
+	OV_ERR_FAIL_INDEX(group_id, groups.size());
+	client_manager->broadcast_packet(PacketTypes::modify_chat_group, PacketChatGroupModifyData { group_id, clients });
+}
+
+void ChatManager::_set_group(ChatGroup::index_t group_id, memory::vector<BaseMultiplayerManager::client_id_type>&& clients) {
+	ChatGroup& group = groups[group_id];
+	std::swap(group.clients, clients);
+	group_modified(group, clients);
+}
+
+ChatGroup const& ChatManager::get_group(ChatGroup::index_t group_index) const {
+	return groups.at(group_index);
+}
+
+void ChatManager::delete_group(ChatGroup::index_t group_id) {
+	OV_ERR_FAIL_INDEX(group_id, groups.size());
+	client_manager->broadcast_packet(
+		PacketTypes::delete_chat_group,
+		PacketType::argument_type { std::in_place_index<PacketTypes::delete_chat_group.packet_id>, group_id }
+	);
+}
+
+void ChatManager::_delete_group(ChatGroup::index_t group_id) {
+	groups.erase(groups.begin() + group_id);
+	group_deleted(group_id);
+}