Add multiplayer abstractions

Add multi-platform socket abstractions
Add Udp and Tcp client/server socket handlers
Add RingBuffer
Add PacketReaderAdapter
Add PacketBuilder
Deduplicate stack_string behaviors into StackString
Add `GameManager::get_elapsed_microseconds`
Add `GameManager::get_elapsed_milliseconds`
Add RingBuffer tests
Add IpAddress tests
Add UdpServer tests
Add ReliableUdpServer tess
Add TcpServer tests
Add mas-bandwidth/reliable@57b0c90

Author: Spartan322

.gitmodules

@@ -26,3 +26,6 @@
 [submodule "tests/benchmarks/deps/nanobench"]
 	path = tests/benchmarks/deps/nanobench
 	url = https://github.com/Spartan322/nanobench
+[submodule "deps/reliable"]
+	path = deps/reliable
+	url = https://github.com/mas-bandwidth/reliable

deps/SCsub

@@ -45,6 +45,36 @@ def build_std_function(env):
     env.Append(CPPPATH=env.std_function["INCPATH"])
     env.exposed_includes += env.std_function["INCPATH"]
 
+def build_reliable(env):
+    import os
+
+    if env["dev_build"]:
+        env.Append(CPPDEFINES=["RELIABLE_DEBUG"])
+    else:
+        env.Append(CPPDEFINES=["RELIABLE_RELEASE"])
+    reliable_env = env.Clone()
+
+    include_path = "reliable"
+    include_dir = reliable_env.Dir(include_path)
+    sources = [os.path.join(include_path, "reliable.c")]
+    env.reliable_sources = sources
+    library_name = "libreliable" + env["LIBSUFFIX"]
+    library = reliable_env.StaticLibrary(target=os.path.join(include_path, library_name), source=sources)
+    Default(library)
+
+    env.reliable = {}
+    env.reliable["INCPATH"] = [include_dir]
+
+    env.Append(CPPPATH=env.reliable["INCPATH"])
+    if env.get("is_msvc", False):
+        env.Append(CXXFLAGS=["/external:I", include_dir, "/external:W0"])
+    else:
+        env.Append(CXXFLAGS=["-isystem", include_dir])
+    env.Append(LIBPATH=include_dir)
+    env.Prepend(LIBS=[library_name])
+
+    env.exposed_includes += env.reliable["INCPATH"]
+
 def link_tbb(env):
     import sys
     if not env.get("is_msvc", False) and not env.get("use_mingw", False) and sys.platform != "darwin":
@@ -56,4 +86,5 @@ build_ordered_map(env)
 build_colony(env)
 build_function2(env)
 build_std_function(env)
+build_reliable(env)
 link_tbb(env)

deps/reliable

@@ -117,9 +117,12 @@ static bool run_headless(fs::path const& root, std::vector<std::string>& mods, b
 	Dataloader::path_vector_t roots = { root };
 	Dataloader::path_vector_t replace_paths = {};
 
-	GameManager game_manager { []() {
-		Logger::info("State updated");
-	} };
+	GameManager game_manager {
+		[] {
+			Logger::info("State updated");
+		},
+		nullptr, nullptr
+	};
 
 	Logger::info("Commit hash: ", GameManager::get_commit_hash());
 

src/headless/main.cpp

@@ -1,12 +1,39 @@
 #include "GameManager.hpp"
 
+#include <chrono>
+
 using namespace OpenVic;
 
+static std::chrono::time_point elapsed_time_begin = std::chrono::high_resolution_clock::now();
+
+GameManager::elapsed_time_getter_func_t GameManager::get_elapsed_usec_time_callback = []() -> uint64_t {
+	std::chrono::time_point current = std::chrono::high_resolution_clock::now();
+	return std::chrono::duration_cast<std::chrono::microseconds>(current - elapsed_time_begin).count();
+};
+
+GameManager::elapsed_time_getter_func_t GameManager::get_elapsed_msec_time_callback = []() -> uint64_t {
+	std::chrono::time_point current = std::chrono::high_resolution_clock::now();
+	return std::chrono::duration_cast<std::chrono::milliseconds>(current - elapsed_time_begin).count();
+};
+
 GameManager::GameManager(
-	InstanceManager::gamestate_updated_func_t new_gamestate_updated_callback
+	InstanceManager::gamestate_updated_func_t new_gamestate_updated_callback,
+	elapsed_time_getter_func_t new_get_elapsed_usec_callback,
+	elapsed_time_getter_func_t new_get_elapsed_msec_callback
 ) : gamestate_updated_callback {
 		new_gamestate_updated_callback ? std::move(new_gamestate_updated_callback) : []() {}
-	}, definitions_loaded { false }, mod_descriptors_loaded { false } {}
+	}, definitions_loaded { false }, mod_descriptors_loaded { false } {
+	if (new_get_elapsed_usec_callback) {
+		get_elapsed_usec_time_callback = { std::move(new_get_elapsed_usec_callback) };
+	}
+	if (new_get_elapsed_msec_callback) {
+		get_elapsed_msec_time_callback = { std::move(new_get_elapsed_msec_callback) };
+	}
+
+	if (bool(new_get_elapsed_usec_callback) != bool(new_get_elapsed_msec_callback)) {
+		Logger::warning("Only one of the elapsed time callbacks was set.");
+	}
+}
 
 bool GameManager::load_mod_descriptors(std::span<const std::string> descriptors) {
 	if (mod_descriptors_loaded) {
@@ -97,3 +124,11 @@ bool GameManager::update_clock() {
 
 	return instance_manager->update_clock();
 }
+
+uint64_t GameManager::get_elapsed_microseconds() {
+	return get_elapsed_usec_time_callback();
+}
+
+uint64_t GameManager::get_elapsed_milliseconds() {
+	return get_elapsed_msec_time_callback();
+}

src/openvic-simulation/GameManager.cpp

@@ -10,9 +10,16 @@
 #include "openvic-simulation/misc/GameRulesManager.hpp"
 #include "openvic-simulation/gen/commit_info.gen.hpp"
 
+#include <function2/function2.hpp>
+
 namespace OpenVic {
 	struct GameManager {
+		using elapsed_time_getter_func_t = fu2::function_base<true, true, fu2::capacity_none, false, false, uint64_t() const>;
+
 	private:
+		static elapsed_time_getter_func_t get_elapsed_usec_time_callback;
+		static elapsed_time_getter_func_t get_elapsed_msec_time_callback;
+
 		GameRulesManager PROPERTY(game_rules_manager);
 		Dataloader PROPERTY(dataloader);
 		DefinitionManager PROPERTY(definition_manager);
@@ -25,7 +32,9 @@ namespace OpenVic {
 
 	public:
 		GameManager(
-			InstanceManager::gamestate_updated_func_t new_gamestate_updated_callback
+			InstanceManager::gamestate_updated_func_t new_gamestate_updated_callback,
+			elapsed_time_getter_func_t new_get_elapsed_usec_callback,
+			elapsed_time_getter_func_t new_get_elapsed_msec_callback
 		);
 
 		inline constexpr InstanceManager* get_instance_manager() {
@@ -55,5 +64,8 @@ namespace OpenVic {
 		static constexpr uint64_t get_commit_timestamp() {
 			return SIM_COMMIT_TIMESTAMP;
 		}
+
+		static uint64_t get_elapsed_microseconds();
+		static uint64_t get_elapsed_milliseconds();
 	};
 }

src/openvic-simulation/GameManager.hpp

@@ -0,0 +1,30 @@
+
+#include "HostnameAddress.hpp"
+
+#include <charconv>
+#include <system_error>
+
+#include "openvic-simulation/multiplayer/lowlevel/IpAddress.hpp"
+#include "openvic-simulation/multiplayer/lowlevel/NetworkResolver.hpp"
+
+using namespace OpenVic;
+
+HostnameAddress::HostnameAddress() = default;
+
+HostnameAddress::HostnameAddress(IpAddress const& address) : _resolved_address(address) {}
+
+HostnameAddress::HostnameAddress(std::string_view name_or_address) : HostnameAddress() {
+	std::from_chars_result result =
+		_resolved_address.from_chars(name_or_address.data(), name_or_address.data() + name_or_address.size());
+	if (result.ec != std::errc {}) {
+		_resolved_address = NetworkResolver::singleton().resolve_hostname(name_or_address);
+	}
+}
+
+IpAddress const& HostnameAddress::resolved_address() const {
+	return _resolved_address;
+}
+
+void HostnameAddress::set_resolved_address(IpAddress const& address) {
+	_resolved_address = address;
+}

src/openvic-simulation/multiplayer/lowlevel/HostnameAddress.cpp

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <string_view>
+
+#include "openvic-simulation/multiplayer/lowlevel/IpAddress.hpp"
+
+namespace OpenVic {
+	struct HostnameAddress {
+		HostnameAddress();
+		HostnameAddress(IpAddress const& address);
+		HostnameAddress(std::string_view name_or_address);
+
+		IpAddress const& resolved_address() const;
+		void set_resolved_address(IpAddress const& address);
+
+	private:
+		IpAddress _resolved_address;
+	};
+}

src/openvic-simulation/multiplayer/lowlevel/HostnameAddress.hpp

@@ -0,0 +1,18 @@
+#include "IpAddress.hpp"
+
+#include <string>
+
+using namespace OpenVic;
+
+std::string IpAddress::to_string(bool prefer_ipv4, to_chars_option option) const {
+	stack_string result = to_array(prefer_ipv4, option);
+	if (OV_unlikely(result.empty())) {
+		return {};
+	}
+
+	return result;
+}
+
+IpAddress::operator std::string() const {
+	return to_string();
+}