Revamp: Transition HarmonyLink to C++ with DLL support

This transformative commit marks the evolution of HarmonyLink from a Rust-based server-side application to a C++ implemented, C-compatible dynamic link library (DLL). We've restructured the codebase to streamline integration into games, eliminating the need for a server setup by end-users.

Key Changes:
- Introduced .gitattributes and .gitmodules to manage new dependencies and collaborations.
- Replaced the GitHub workflow files with CMake configurations to support the new C++ build system.
- Introduced a comprehensive set of header and implementation files defining the core functionality, platform-specific utilities, and cross-platform compatibility layers.
- Removed all Rust-specific files (Cargo.toml, Cargo.lock, etc.) and references to ensure a clean transition to the C++ environment.
- Implemented new testing mechanisms within HarmonyLinkTest to ensure robustness and reliability of the DLL.
- Excised previous server-side components and models to focus on the DLL's direct integration into consumer applications.

This update is a direct response to community feedback, showcasing our commitment to adaptability and innovation. HarmonyLink 2.0 is now more accessible, efficient, and tailored for diverse gaming environments, providing developers with an unparalleled level of hardware-software harmony.

Please refer to the updated README for more details on the new structure and how to integrate HarmonyLink 2.0 into your projects.

HarmonyLinkLib/CMakeLists.txt

@@ -0,0 +1,129 @@
+cmake_minimum_required(VERSION 3.10)
+project(HarmonyLinkLib VERSION 2.0.0)
+
+# Find the current Git branch and the last commit timestamp
+find_package(Git QUIET)
+if(GIT_FOUND)
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} rev-parse --abbrev-ref HEAD
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_BRANCH_NAME
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+    execute_process(
+        COMMAND ${GIT_EXECUTABLE} log -1 --format=%ct
+        WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        OUTPUT_VARIABLE GIT_COMMIT_TIMESTAMP
+        OUTPUT_STRIP_TRAILING_WHITESPACE
+    )
+else()
+    set(GIT_BRANCH_NAME "Unknown")
+    set(GIT_COMMIT_TIMESTAMP "Unknown")
+endif()
+
+configure_file(include/Version.h.in Version.generated.h)
+
+# Specify the C++ standard
+set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED True)
+
+# Explicitly list source files
+set(COMMON_SOURCES
+    "src/Platform/IPlatformUtilities.cpp"
+    "src/HarmonyLinkLib.cpp"
+    "src/Version.cpp"
+    "src/dllmain.cpp"
+    "src/Platform/WineUtilities.cpp"
+)
+
+# Explicitly list include files
+set(COMMON_INCLUDES
+    "include/Core.h"
+    "include/Structs/FBattery.h"
+    "include/Structs/FOSVerInfo.h"
+    "include/Structs/FDevice.h"
+    "include/Structs/FCPUInfo.h"
+    
+    "include/Enums/EDevice.h"
+    "include/Enums/EPlatform.h"
+    
+    "include/FString.h"
+    "include/HarmonyLinkLib.h"
+    "include/Version.h"
+    
+    "src/Platform/IPlatformUtilities.h"
+    "src/Platform/WineUtilities.h"
+)
+
+set(WINDOWS_SOURCES
+    "src/Platform/Windows/WindowsUtilities.cpp"
+)
+
+set(WINDOWS_INCLUDES
+    "src/Platform/Windows/WindowsUtilities.h"
+)
+
+set(LINUX_SOURCES
+    "src/Platform/Unix/Linux/LinuxUtilities.cpp"
+    "src/Platform/Unix/UnixUtilities.cpp"
+)
+
+set(LINUX_INCLUDES
+    "src/Platform/Unix/Linux/LinuxUtilities.h"
+    "src/Platform/Unix/UnixUtilities.h"
+)
+
+set(MAC_SOURCES
+    "src/Platform/Unix/Mac/MacUtilities.cpp"
+    "src/Platform/Unix/UnixUtilities.cpp"
+)
+
+set(MAC_INCLUDES
+    "src/Platform/Unix/Mac/MacUtilities.h"
+    "src/Platform/Unix/UnixUtilities.h"
+)
+
+# Platform-specific definitions
+if(WIN32)
+    message(STATUS "Compiling for Windows...")
+    list(APPEND LIB_SOURCES ${COMMON_SOURCES} ${WINDOWS_SOURCES})
+    list(APPEND LIB_INCLUDES ${COMMON_INCLUDES} ${WINDOWS_INCLUDES})
+elseif(UNIX)
+  message(STATUS "Compiling for Unix-based systems...")
+  if(APPLE)
+    message(STATUS "Compiling for Mac...")
+    list(APPEND LIB_SOURCES ${COMMON_SOURCES} ${MAC_SOURCES})
+    list(APPEND LIB_INCLUDES ${COMMON_INCLUDES} ${MAC_INCLUDES})
+  else()
+    message(STATUS "Compiling for Linux...")
+    list(APPEND LIB_SOURCES ${COMMON_SOURCES} ${LINUX_SOURCES})
+    list(APPEND LIB_INCLUDES ${COMMON_INCLUDES} ${LINUX_INCLUDES})
+  endif()
+endif()
+
+# Add library
+add_library(HarmonyLinkLib SHARED ${LIB_SOURCES} ${LIB_INCLUDES})
+
+target_include_directories(HarmonyLinkLib 
+    PRIVATE 
+        "${PROJECT_SOURCE_DIR}/src"
+    PUBLIC 
+        "${PROJECT_BINARY_DIR}"
+        "${PROJECT_SOURCE_DIR}/include"
+)
+
+target_compile_definitions(HarmonyLinkLib PRIVATE HARMONYLINKLIB_EXPORTS)
+
+if(CMAKE_BUILD_TYPE STREQUAL "Debug")
+    target_compile_definitions(HarmonyLinkLib PRIVATE "DEBUG_MODE")
+endif()
+
+# Set output directories for all build types
+foreach(TYPE IN ITEMS DEBUG RELEASE)
+    string(TOUPPER ${TYPE} TYPE_UPPER)
+    set_target_properties(${PROJECT_NAME} PROPERTIES
+        RUNTIME_OUTPUT_DIRECTORY_${TYPE_UPPER} "${CMAKE_BINARY_DIR}/bin/${TYPE}/${PROJECT_NAME}"
+        LIBRARY_OUTPUT_DIRECTORY_${TYPE_UPPER} "${CMAKE_BINARY_DIR}/lib/${TYPE}/${PROJECT_NAME}"
+        ARCHIVE_OUTPUT_DIRECTORY_${TYPE_UPPER} "${CMAKE_BINARY_DIR}/archive/${TYPE}/${PROJECT_NAME}"
+    )
+endforeach()

HarmonyLinkLib/include/Core.h

@@ -0,0 +1,14 @@
+// Copyright (C) 2023  Jordon Brooks
+
+#pragma once
+
+// Use a preprocessor definition to switch between export and import declarations
+#ifdef _WIN32
+    #ifdef HARMONYLINKLIB_EXPORTS
+        #define HARMONYLINKLIB_API __declspec(dllexport)
+    #else
+        #define HARMONYLINKLIB_API __declspec(dllimport)
+    #endif
+#else
+    #define HARMONYLINKLIB_API
+#endif

HarmonyLinkLib/include/Enums/EDevice.h

@@ -0,0 +1,19 @@
+#pragma once
+
+#include <cstdint>
+
+// Enum class for representing different types of devices
+namespace HarmonyLinkLib
+{
+    enum class EDevice : uint8_t
+    {
+        DESKTOP,
+        LAPTOP,
+        HANDHELD,
+    
+        STEAM_DECK,
+        // ROG_ALLY
+        // AYONEO_SLIDE
+        // etc...
+    };
+}

HarmonyLinkLib/include/Enums/EPlatform.h

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <cstdint>
+
+// Enum class for representing different operating platforms
+namespace HarmonyLinkLib
+{
+    enum class EPlatform : uint8_t
+    {
+        WINDOWS,
+        LINUX,
+        MAC,
+        UNIX,
+    };
+}

HarmonyLinkLib/include/FString.h

@@ -0,0 +1,165 @@
+// Copyright (C) 2024  Jordon Brooks
+
+#pragma once
+
+#include <memory>
+#include <cstring>
+#include <string>
+
+#include "Core.h"  // Replace with actual API export macro
+
+/**
+ * @file FString.h
+ * @brief FString Class - Custom String Management for DLL Export
+ *
+ * The FString class is a custom string management class designed to safely encapsulate
+ * string handling and memory management, especially for use in DLLs (Dynamic Link Libraries).
+ * It resolves the common issue of exporting classes containing standard library types,
+ * such as std::string, across DLL boundaries, which can lead to compiler warnings or errors.
+ *
+ * Features:
+ * - Implements basic string operations such as construction, destruction, copy, and move semantics.
+ * - Utilizes smart pointers (std::unique_ptr) for automatic memory management, reducing the risk of memory leaks.
+ * - Provides a simple interface for interacting with character strings, similar to std::string.
+ * - Includes both deep copy semantics for safety and move semantics for performance in object transfers.
+ *
+ * Usage:
+ * FString can be used as a safer alternative to std::string for classes that are exported from a DLL.
+ * It handles memory allocation/deallocation automatically and provides a basic set of string operations.
+ * 
+ * Example:
+ *     FString myString("Hello, world!");
+ *     std::cout << myString.c_str() << std::endl; // Output: Hello, world!
+ *
+ * Note:
+ * - The class is currently designed with basic functionality. Additional features such as
+ *   string concatenation, substring, and comparison operations can be added as needed.
+ * - Ensure that the HarmonyLinkLibApi.h (or equivalent) file correctly defines the export macro
+ *   for DLL usage.
+ *
+ */
+ namespace HarmonyLinkLib
+ {
+    class HARMONYLINKLIB_API FString {
+    public:
+        FString() : data_(new char[1]) {
+            data_[0] = '\0';
+        }
+
+        FString(const char* str) {
+            const size_t len = strlen(str);
+            data_ = new char[len + 1];
+            memcpy(data_, str, len + 1);
+        }
+
+        // Copy constructor
+        FString(const FString& other) {
+            const size_t len = strlen(other.data_);
+            data_ = new char[len + 1];
+            memcpy(data_, other.data_, len + 1);
+        }
+
+        ~FString() {
+            delete[] data_;
+        }
+
+        // Copy assignment operator
+        FString& operator=(const FString& other) {
+            if (this != &other) {
+                delete[] data_;
+                const size_t len = strlen(other.data_);
+                data_ = new char[len + 1];
+                memcpy(data_, other.data_, len + 1);
+            }
+            return *this;
+        }
+
+        // Concatenation operator for FString objects
+        FString operator+(const FString& other) const {
+            size_t thisLen = strlen(this->data_);
+            size_t otherLen = strlen(other.data_);
+            char* concatenated = new char[thisLen + otherLen + 1];
+
+            memcpy(concatenated, this->data_, thisLen);
+            memcpy(concatenated + thisLen, other.data_, otherLen + 1);
+
+            FString result(concatenated);
+            delete[] concatenated;
+            return result;
+        }
+
+        // Concatenation operator for const char* 
+        FString operator+(const char* other) const {
+            return *this + FString(other);
+        }
+
+        // Friend function to allow concatenation with const char* on the left-hand side
+        friend FString operator+(const char* lhs, const FString& rhs) {
+            return FString(lhs) + rhs;
+        }
+
+        // Move constructor
+        FString(FString&& other) noexcept : data_(other.data_) {
+            other.data_ = nullptr;
+        }
+
+        FString(const std::string& str) {
+            const size_t len = str.length();
+            data_ = new char[len + 1];
+            memcpy(data_, str.c_str(), len + 1);
+        }
+
+        // Move assignment operator
+        FString& operator=(FString&& other) noexcept {
+            if (this != &other) {
+                delete[] data_;
+                data_ = other.data_;
+                other.data_ = nullptr;
+            }
+            return *this;
+        }
+
+        bool operator==(const FString& other) const {
+            return strcmp(data_, other.data_) == 0;
+        }
+
+        // Method to get a lowercase version of the string
+        static FString to_lower(FString& from)
+        {
+            for (size_t i = 0; i < strlen(from.data_); ++i) {
+                from.data_[i] = static_cast<char>(std::tolower(static_cast<unsigned char>(from.data_[i])));
+            }
+            return from;
+        }
+
+        // Overloaded static method to handle const char*
+        static FString to_lower(const char* from) {
+            FString temp_string(from); // Create an FString from const char*
+            return to_lower(temp_string); // Reuse the existing to_lower method
+        }
+
+        const char* c_str() const {
+            return data_;
+        }
+
+    private:
+        char* data_ = nullptr;
+    };
+ }
+
+namespace std {
+    template<>
+    struct hash<HarmonyLinkLib::FString> {
+        size_t operator()(const HarmonyLinkLib::FString& s) const {
+            size_t hashValue = 5381;  // Starting value recommended by the djb2 algorithm
+            const char* str = s.c_str();
+
+            for (size_t i = 0; str[i] != '\0'; ++i) {
+                hashValue = ((hashValue << 5) + hashValue) + static_cast<unsigned char>(str[i]);
+                // Equivalent to hashValue * 33 + str[i]
+            }
+
+            return hashValue;
+        }
+    };
+}

HarmonyLinkLib/include/HarmonyLinkLib.h

@@ -0,0 +1,44 @@
+// Copyright (C) 2023  Jordon Brooks
+
+
+/**
+ * IMPORTANT REMINDER:
+ * Do NOT use standard output functions like std::cout and printf anywhere in this codebase.
+ *
+ * Reason:
+ * Unreal Engine 5's packaging tool encounters issues with these functions, leading to 
+ * packaging failures. The engine sets stdout to UTF-8, which can cause conflicts with
+ * these standard functions, resulting in a "SECURE CRT: Invalid parameter detected" error 
+ * during packaging.
+ *
+ * This issue once required an extensive debugging effort that lasted over 8 hours. 
+ * To prevent similar issues in the future and ensure smooth packaging, always use 
+ * wide-character versions of these functions, such as wprintf and std::wcout, when working 
+ * within the DLL. These functions are compatible with the UTF-8 setting in Unreal Engine 5.
+ *
+ */
+
+
+#pragma once
+
+#include "Core.h"
+#include "Structs/FBattery.h"
+#include "Structs/FCPUInfo.h"
+#include "Structs/FDevice.h"
+#include "Structs/FOSVerInfo.h"
+
+
+class IPlatformUtilities;
+
+namespace HarmonyLinkLib
+{
+    extern "C" HARMONYLINKLIB_API bool get_is_wine();
+
+    extern "C" HARMONYLINKLIB_API FCPUInfo* get_cpu_info();
+
+    extern "C" HARMONYLINKLIB_API FDevice* get_device_info();
+
+    extern "C" HARMONYLINKLIB_API FOSVerInfo* get_os_version();
+    
+    extern "C" HARMONYLINKLIB_API FBattery* get_battery_status();
+}

HarmonyLinkLib/include/HarmonyLinkStruct.h

@@ -0,0 +1,13 @@
+#pragma once
+
+struct HarmonyLinkStruct
+{
+    // Virtual destructor is important for proper cleanup of derived types
+    virtual ~HarmonyLinkStruct() = default;
+
+    // Method to deallocate the object
+    void free() const
+    {
+        delete this;
+    }
+};

HarmonyLinkLib/include/Structs/FBattery.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <cstdint>
+#include <iostream>
+
+#include "HarmonyLinkStruct.h"
+
+namespace HarmonyLinkLib
+{
+    struct FBattery : HarmonyLinkStruct
+    {
+        bool has_battery;
+        bool is_connected_to_ac;
+        uint8_t battery_percent;
+
+        void to_string() const {
+            std::wcout << "Battery present: " << (has_battery ? "'Yes'" : "'No'") << '\n';
+            std::wcout << "Connected to AC: " << (is_connected_to_ac ? "'Yes'" : "'No'") << '\n';
+            std::wcout << "Battery percent: '" << static_cast<int>(battery_percent) << "%'" << '\n';
+        }
+    };
+}

HarmonyLinkLib/include/Structs/FCPUInfo.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstdint>
+#include <unordered_set>
+#include "FString.h"
+
+#include "HarmonyLinkStruct.h"
+
+namespace HarmonyLinkLib
+{
+    struct FCPUInfo : HarmonyLinkStruct
+    {
+        FString VendorID;
+        FString Model_Name;
+        uint32_t Physical_Cores = 0;
+        uint32_t Logical_Cores = 0;
+        std::unordered_set<FString> Flags;
+
+        void print() const
+        {
+            wprintf(L"VendorID: '%hs'\n", VendorID.c_str());
+            wprintf(L"Model_Name: '%hs'\n", Model_Name.c_str());
+            wprintf(L"Physical_Cores: '%d'\n", Physical_Cores);
+            wprintf(L"Logical_Cores: '%d'\n", Logical_Cores);
+            
+            // Initialize a string to hold all flags
+            std::string allFlags;
+            for (const auto& flag : Flags) {
+                allFlags += std::string(flag.c_str()) + " "; // Append each flag followed by a space
+            }
+
+            // Remove the trailing space
+            if (!allFlags.empty()) {
+                allFlags.pop_back();
+            }
+
+            wprintf(L"Flags: '%hs'\n", allFlags.c_str());
+        }
+    };
+}

HarmonyLinkLib/include/Structs/FDevice.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <HarmonyLinkStruct.h>
+
+#include "Enums/EDevice.h"
+#include "Enums/EPlatform.h"
+
+namespace HarmonyLinkLib
+{
+    // Struct to represent a specific device with both platform and device type
+    struct FDevice : HarmonyLinkStruct
+    {
+        EPlatform platform;
+        EDevice device;
+    };
+}

HarmonyLinkLib/include/Structs/FOSVerInfo.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "FString.h"
+#include "HarmonyLinkStruct.h"
+
+namespace HarmonyLinkLib
+{
+    struct FOSVerInfo : HarmonyLinkStruct {
+    // 'name' represents the operating system's name, e.g., "Ubuntu" in Linux or "Windows" in Windows systems.
+    FString name;
+    
+    // 'version' is a numerical representation of the OS version. In Linux, it might be the kernel version, 
+    // whereas in Windows, it could be the major version number like 10 for Windows 10.
+    uint32_t version = 0;
+
+    // 'id' is a unique identifier for the OS. In Linux, it might be a lower-case string like "ubuntu". 
+    // In Windows, this could map to the edition ID, such as "Professional".
+    FString id;
+
+    // 'version_id' is a string representing the specific version of the OS. 
+    // For example, "20.04" in Ubuntu or "1909" in Windows 10.
+    FString version_id;
+
+    // 'version_codename' is a codename for the OS version, if available. 
+    // This is common in Linux distributions (e.g., "focal" for Ubuntu 20.04) but not typically used in Windows.
+    FString version_codename;
+
+    // 'pretty_name' is a more readable version of the name, potentially including the version and codename.
+    // For example, "Ubuntu 20.04 LTS (Focal Fossa)" or "Windows 10 Pro".
+    FString pretty_name;
+
+    // 'variant_id' is an identifier for the specific variant of the OS, if available.
+    // For example, in Linux distributions, this might be "desktop" for the desktop edition, 
+    // "server" for the server edition, or "core" for a minimal installation. It helps distinguish
+    // between different flavors or editions of the same version.
+    // On the Steam Deck, this is set to "steamdeck".
+    FString variant_id;
+
+    void print() const
+    {
+        wprintf(L"Name: '%hs'\n", name.c_str());
+        wprintf(L"Version: '%d'\n", version);
+        wprintf(L"ID: '%hs'\n", id.c_str());
+        wprintf(L"Version ID: '%hs'\n", version_id.c_str());
+        wprintf(L"Version Codename: '%hs'\n", version_codename.c_str());
+        wprintf(L"Pretty Name: '%hs'\n", pretty_name.c_str());
+        wprintf(L"Variant ID: '%hs'\n", variant_id.c_str());
+    }
+};
+}

HarmonyLinkLib/include/Version.h

@@ -0,0 +1,45 @@
+// Copyright (C) 2024  Jordon Brooks
+#pragma once
+
+#include "Core.h"
+#include <Version.generated.h>
+
+#include "FString.h"
+
+namespace HarmonyLinkLib
+{
+    class HARMONYLINKLIB_API version
+    {
+    public:
+        version() = default;
+    
+        static FString ToString()
+        {
+            return HARMONYLINK_VERSION;
+        }
+
+        static FString get_build_timestamp()
+        {
+            return {__TIMESTAMP__};
+        }
+
+        static FString get_git_branch()
+        {
+            return {GIT_BRANCH_NAME};
+        }
+
+        static FString get_git_commit_timestamp()
+        {
+            return {GIT_COMMIT_TIMESTAMP};
+        }
+
+        static bool is_debug()
+        {
+#ifdef DEBUG_MODE
+            return true;
+#else
+            return false;
+#endif
+        }
+    };
+}

HarmonyLinkLib/include/Version.h.in

@@ -0,0 +1,11 @@
+// Version.h.in
+#pragma once
+
+#define HARMONYLINK_VERSION_MAJOR @HarmonyLinkLib_VERSION_MAJOR@
+#define HARMONYLINK_VERSION_MINOR @HarmonyLinkLib_VERSION_MINOR@
+#define HARMONYLINK_VERSION_PATCH @HarmonyLinkLib_VERSION_PATCH@
+#define HARMONYLINK_VERSION_TWEAK @HarmonyLinkLib_VERSION_TWEAK@
+#define HARMONYLINK_VERSION "@HarmonyLinkLib_VERSION@"
+
+#define GIT_BRANCH_NAME "@GIT_BRANCH_NAME@"
+#define GIT_COMMIT_TIMESTAMP "@GIT_COMMIT_TIMESTAMP@"

HarmonyLinkLib/src/HarmonyLinkLib.cpp

@@ -0,0 +1,94 @@
+#include "HarmonyLinkLib.h"
+
+#include <iostream>
+#include "Platform/IPlatformUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    std::shared_ptr<IPlatformUtilities> PlatformUtilities = IPlatformUtilities::GetInstance();
+
+    bool get_is_wine()
+    {
+        if (!PlatformUtilities)
+        {
+            std::wcout << "Failed to get platform utilities!\n";
+            return false;
+        }
+
+        return PlatformUtilities->is_running_under_wine();
+    }
+
+    FCPUInfo* get_cpu_info()
+    {
+        if (!PlatformUtilities)
+        {
+            std::wcout << "Failed to get platform utilities!\n";
+            return nullptr;
+        }
+
+        const std::shared_ptr<FCPUInfo> cpu_info = PlatformUtilities->get_cpu_info();
+        if (!cpu_info)
+        {
+            return nullptr;
+        }
+
+        FCPUInfo* new_cpu_info = new FCPUInfo(*cpu_info);
+        return new_cpu_info;
+    }
+
+    FDevice* get_device_info()
+    {
+        if (!PlatformUtilities)
+        {
+            std::wcout << "Failed to get platform utilities!\n";
+            return nullptr;
+        }
+
+        const std::shared_ptr<FDevice> device = PlatformUtilities->get_device();
+        if (!device)
+        {
+            return nullptr;
+        }
+
+        FDevice* new_device = new FDevice(*device);
+        return new_device;
+    }
+
+    FOSVerInfo* get_os_version()
+    {
+    
+
+        if (!PlatformUtilities)
+        {
+            std::wcout << "Failed to get platform utilities!\n";
+            return nullptr;
+        }
+
+        const std::shared_ptr<FOSVerInfo> os_version_info = PlatformUtilities->get_os_version();
+        if (!os_version_info)
+        {
+            return nullptr;
+        }
+
+        FOSVerInfo* new_os_info = new FOSVerInfo(*os_version_info);
+        return new_os_info;
+    }
+
+    FBattery* get_battery_status()
+    {
+        if (!PlatformUtilities)
+        {
+            std::wcout << "Failed to get platform utilities!\n";
+            return nullptr;
+        }
+
+        const std::shared_ptr<FBattery> new_battery = PlatformUtilities->get_battery_status();
+        if (!new_battery)
+        {
+            return nullptr;
+        }
+
+        FBattery* battery = new FBattery(*new_battery);
+        return battery;
+    }
+}

HarmonyLinkLib/src/Platform/IPlatformUtilities.cpp

@@ -0,0 +1,122 @@
+#include "IPlatformUtilities.h"
+
+#include <set>
+
+#include "WineUtilities.h"
+#if BUILD_WINDOWS
+#include "Windows/WindowsUtilities.h"
+#elif BUILD_LINUX
+#include "Unix/Linux/LinuxUtilities.h"
+#elif BUILD_MAC
+#include "Unix/Mac/MacUtilities.h"
+#elif BUILD_UNIX
+#include "Unix/Mac/MacUtilities.h"
+#endif
+
+namespace HarmonyLinkLib
+{
+    static std::shared_ptr<IPlatformUtilities> INSTANCE = nullptr;
+
+std::shared_ptr<IPlatformUtilities>& IPlatformUtilities::GetInstance()
+{
+    if (!INSTANCE)
+    {
+#if BUILD_WINDOWS
+        INSTANCE = std::make_shared<WindowsUtilities>();
+#elif BUILD_LINUX
+        INSTANCE = std::make_shared<LinuxUtilities>();
+#elif BUILD_MAC
+        INSTANCE = std::make_shared<MacUtilities>();
+#elif BUILD_UNIX
+        INSTANCE = std::make_shared<UnixUtilities>();
+// ... other platform checks
+#else
+        std::wcout << "Platform is not supported.\n"
+#endif
+    }
+    
+    return INSTANCE;
+}
+
+bool IPlatformUtilities::is_running_under_wine()
+{
+    return WineUtilities::is_wine_present();
+}
+
+bool IPlatformUtilities::is_linux()
+{
+#ifdef BUILD_LINUX
+    return true;
+#else
+    return is_running_under_wine();
+#endif
+}
+
+std::shared_ptr<FDevice> IPlatformUtilities::get_device()
+{
+    FDevice new_device;
+    
+    if (is_linux())
+    {
+        new_device.platform = EPlatform::LINUX;
+    }
+    else
+    {
+        new_device.platform = EPlatform::WINDOWS;
+    }
+
+    const std::shared_ptr<FBattery> battery_status = get_battery_status();
+
+    if (battery_status && !battery_status->has_battery)
+    {
+        new_device.device = EDevice::DESKTOP;
+    }
+    else
+    {
+        new_device.device = EDevice::LAPTOP;
+    }
+
+    if (is_steam_deck(new_device)) {
+        new_device.device = EDevice::STEAM_DECK;
+    }
+    return std::make_shared<FDevice>(new_device);
+}
+
+// Helper function to check if the device is a Steam Deck
+bool IPlatformUtilities::is_steam_deck(const FDevice& device) {
+
+    // Check if the device is already identified as a Steam Deck
+    if (device.device == EDevice::STEAM_DECK) {
+        return true;
+    }
+
+    // Check for Steam Deck by OS version
+    if (const std::shared_ptr<FOSVerInfo> version = get_os_version()) {
+        if (version->variant_id == "steamdeck" && version->name == "SteamOS") {
+            return true;
+        }
+    } else {
+        wprintf(L"OS version information not available.\n");
+    }
+
+    // Set of known Steam Deck CPU model names
+    const std::set<std::string> steam_deck_models = {"amd custom apu 0405" /*, other models... */};
+
+    // Check for Steam Deck by CPU model name
+    if (const std::shared_ptr<FCPUInfo> cpu_info = get_cpu_info()) {
+        const FString cpu_model_lower = FString::to_lower(cpu_info->Model_Name);
+        for (const auto& model : steam_deck_models) {
+            if (cpu_model_lower == model) {
+                wprintf(L"Steam Deck detected by CPU model name.\n");
+                return true;
+            }
+        }
+    } else {
+        wprintf(L"CPU information not available.\n");
+    }
+
+    wprintf(L"Device is not a Steam Deck.\n");
+    
+    return false;
+}
+}

HarmonyLinkLib/src/Platform/IPlatformUtilities.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "Structs/FBattery.h"
+#include "Structs/FCPUInfo.h"
+#include "Structs/FDevice.h"
+#include "Structs/FOSVerInfo.h"
+
+namespace HarmonyLinkLib
+{
+    class IPlatformUtilities {
+    public:
+        static std::shared_ptr<IPlatformUtilities>& GetInstance();
+
+        IPlatformUtilities() = default;
+        IPlatformUtilities(const IPlatformUtilities& other) = default;
+        IPlatformUtilities(IPlatformUtilities&& other) = default;
+        IPlatformUtilities& operator=(const IPlatformUtilities& other) = default;
+        IPlatformUtilities& operator=(IPlatformUtilities&& other) = default;
+        virtual ~IPlatformUtilities() = default;
+    
+        // General OS-level functions
+        virtual bool is_running_under_wine();
+        virtual bool is_linux();
+    
+        virtual std::shared_ptr<FDevice> get_device();
+        virtual std::shared_ptr<FCPUInfo> get_cpu_info() = 0;
+        virtual std::shared_ptr<FBattery> get_battery_status() = 0;
+        virtual std::shared_ptr<FOSVerInfo> get_os_version() = 0;
+
+        bool is_steam_deck(const FDevice& device);
+
+        // Add more virtual functions for other OS interactions here
+    };
+}

HarmonyLinkLib/src/Platform/Unix/Linux/LinuxUtilities.cpp

@@ -0,0 +1,24 @@
+#include "LinuxUtilities.h"
+
+
+#include <fstream>
+#include <string>
+#include "Platform/WineUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    std::shared_ptr<FBattery> LinuxUtilities::get_battery_status()
+    {
+        return WineUtilities::get_battery_status();
+    }
+
+    std::shared_ptr<FOSVerInfo> LinuxUtilities::get_os_version()
+    {
+        return WineUtilities::get_linux_info();
+    }
+
+    std::shared_ptr<FCPUInfo> LinuxUtilities::get_cpu_info()
+    {
+        return WineUtilities::get_cpu_info();
+    }
+}

HarmonyLinkLib/src/Platform/Unix/Linux/LinuxUtilities.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#include "Structs/FOSVerInfo.h"
+
+#include "Platform/Unix/UnixUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    class LinuxUtilities : public UnixUtilities {
+    public:
+        // Implementation for other Linux-specific functions
+        std::shared_ptr<FBattery> get_battery_status() override;
+        
+        std::shared_ptr<FOSVerInfo> get_os_version() override;
+
+        std::shared_ptr<FCPUInfo> get_cpu_info() override;
+
+        bool is_linux() override
+        {
+            return true;
+        }
+    };
+}

HarmonyLinkLib/src/Platform/Unix/Mac/MacUtilities.cpp

@@ -0,0 +1,6 @@
+#include "MacUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    
+}

HarmonyLinkLib/src/Platform/Unix/Mac/MacUtilities.h

@@ -0,0 +1,11 @@
+#pragma once
+
+#include "Platform/Unix/UnixUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    class MacUtitities : public UnixUtilities {
+    public:
+        // Mac-specific overrides and additional functionality
+    };
+}

HarmonyLinkLib/src/Platform/Unix/UnixUtilities.cpp

@@ -0,0 +1,24 @@
+#include "UnixUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    bool UnixUtilities::is_running_under_wine()
+    {
+    return false;
+    }
+
+    std::shared_ptr<FCPUInfo> UnixUtilities::get_cpu_info()
+    {
+        return nullptr;
+    }
+
+    std::shared_ptr<FBattery> UnixUtilities::get_battery_status()
+    {
+        return nullptr;
+    }
+
+    std::shared_ptr<FOSVerInfo> UnixUtilities::get_os_version()
+    {
+        return nullptr;
+    }
+}

HarmonyLinkLib/src/Platform/Unix/UnixUtilities.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Platform/IPlatformUtilities.h"
+namespace HarmonyLinkLib
+{
+    class UnixUtilities : public IPlatformUtilities {
+    public:
+        bool is_running_under_wine() override;
+
+        std::shared_ptr<FCPUInfo> get_cpu_info() override;
+        std::shared_ptr<FBattery> get_battery_status() override;
+        std::shared_ptr<FOSVerInfo> get_os_version() override;
+        
+        // Implementation for other Unix/Linux-specific functions
+    };
+}

HarmonyLinkLib/src/Platform/Windows/WindowsUtilities.cpp

@@ -0,0 +1,81 @@
+#include "WindowsUtilities.h"
+
+#include <sstream>
+#include <Windows.h>
+
+#include "Platform/WineUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    std::shared_ptr<FBattery> WindowsUtilities::get_battery_status()
+{
+    if (is_linux())
+    {
+       return WineUtilities::get_battery_status();
+    }
+    FBattery result;
+    
+    SYSTEM_POWER_STATUS status;
+    if (GetSystemPowerStatus(&status)) {
+        result.has_battery = status.BatteryFlag != 128; // 128 indicates no battery
+        result.is_connected_to_ac = status.ACLineStatus == 1;
+        result.battery_percent = result.has_battery ? status.BatteryLifePercent : 0;
+    } else {
+        std::wcout << "Failed to get power statistics.\n";
+    }
+
+    return std::make_shared<FBattery>(result);
+}
+
+std::shared_ptr<FCPUInfo> WindowsUtilities::get_cpu_info()
+{
+    if (is_linux())
+    {
+        return WineUtilities::get_cpu_info();
+    }
+    
+    return {};
+}
+
+std::shared_ptr<FOSVerInfo> WindowsUtilities::get_os_version()
+{
+    if (is_linux())
+    {
+        return WineUtilities::get_linux_info();
+    }
+    
+    OSVERSIONINFOEX os_version_info;
+    ZeroMemory(&os_version_info, sizeof(OSVERSIONINFOEX));
+    os_version_info.dwOSVersionInfoSize = sizeof(OSVERSIONINFOEX);
+
+    if (!GetVersionEx(reinterpret_cast<OSVERSIONINFO*>(&os_version_info))) {
+        // Handle error if needed
+        return nullptr;
+    }
+
+    FOSVerInfo os_version;
+
+    HKEY h_key;
+    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"), 0, KEY_READ, &h_key) == ERROR_SUCCESS)
+    {
+        DWORD dw_size;
+        DWORD dw_type;
+        char sz_product_name[256];
+        dw_size = sizeof(sz_product_name);
+        if (RegQueryValueEx(h_key, TEXT("ProductName"), nullptr, &dw_type, reinterpret_cast<LPBYTE>(sz_product_name), &dw_size) == ERROR_SUCCESS)
+        {
+            os_version.pretty_name = sz_product_name;
+        }
+        RegCloseKey(h_key);
+    }
+
+    std::stringstream version;
+    version << os_version_info.dwMajorVersion << "." << os_version_info.dwMinorVersion;
+    os_version.version_id = version.str();
+
+    os_version.name = "Windows";
+    os_version.version = os_version_info.dwBuildNumber; // Build number as the version
+
+    return std::make_shared<FOSVerInfo>(os_version);
+}
+}

HarmonyLinkLib/src/Platform/Windows/WindowsUtilities.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include "Platform/IPlatformUtilities.h"
+
+namespace HarmonyLinkLib
+{
+    class WindowsUtilities : public IPlatformUtilities
+    {
+    public:
+        std::shared_ptr<FBattery> get_battery_status() override;
+
+        std::shared_ptr<FCPUInfo> get_cpu_info() override;
+    
+        std::shared_ptr<FOSVerInfo> get_os_version() override;
+    };
+}

HarmonyLinkLib/src/Platform/WineUtilities.cpp

@@ -0,0 +1,202 @@
+#include "WineUtilities.h"
+
+#include <fstream>
+#include <iostream>
+#include <sstream>
+#include <unordered_map>
+#include <filesystem>
+
+#ifdef BUILD_WINDOWS
+#include <windows.h>
+#endif
+
+namespace HarmonyLinkLib
+{
+    bool force_detect_wine = false;
+    
+    std::shared_ptr<HarmonyLinkLib::FBattery> HarmonyLinkLib::WineUtilities::get_battery_status()
+    {
+        std::string append;
+        if (is_wine_present())
+        {
+            append = "Z:";
+        }
+
+        FBattery result = {};
+        for (int i = 0; i <= 9; ++i) {
+            if (std::string bat_path = append + "/sys/class/power_supply/BAT" + std::to_string(i); std::filesystem::exists(bat_path)) {
+                result.has_battery = true;
+
+                std::ifstream status_file(bat_path + "/status");
+                std::string status;
+                if (status_file.is_open() && std::getline(status_file, status)) {
+                    if (status == "Charging" || status == "AC") {
+                        result.is_connected_to_ac = true;
+                    }
+                }
+
+                std::ifstream capacity_file(bat_path + "/capacity");
+                if (capacity_file.is_open() && std::getline(capacity_file, status)) {
+                    result.battery_percent = static_cast<uint8_t>(std::stoi(status));
+                    break;  // assuming you only need data from the first battery found
+                }
+            }
+        }
+
+        return std::make_shared<FBattery>(result);
+    }
+
+    std::shared_ptr<FCPUInfo> WineUtilities::get_cpu_info()
+    {
+        std::wcout << "Getting cpu info\n";
+        
+        std::string append;
+        if (is_wine_present())
+        {
+            append = "Z:";
+        }
+
+        FCPUInfo cpu_info;
+        
+        std::ifstream file(append + "/proc/cpuinfo");
+        std::unordered_map<HarmonyLinkLib::FString, HarmonyLinkLib::FString> hashmap;
+
+        if (file) {
+            std::string line;
+            while (std::getline(file, line)) {
+                std::istringstream line_stream(line);
+                std::string key, value;
+                if (std::getline(line_stream, key, ':')) {
+                    key.erase(key.find_last_not_of(" \t") + 1); // Trim trailing whitespace from key
+                    if (std::getline(line_stream, value)) {
+                        value.erase(0, value.find_first_not_of(" \t")); // Trim leading whitespace from value
+
+                        // Aggregate flags
+                        if (key == "flags") {
+                            std::istringstream flag_stream(value);
+                            std::string flag;
+                            while (flag_stream >> flag) {
+                                flag.erase(flag.find_last_not_of(" \t") + 1); // Trim trailing whitespace from flag
+                                cpu_info.Flags.insert(HarmonyLinkLib::FString(flag));
+                                //printf("Flag detected: %s\n", flag.c_str());
+                            }
+                        } else {
+                            hashmap[key] = value;
+                        }
+                    }
+                }
+            }
+            file.close();
+        }
+
+        // Now you can access the values using the keys:
+        cpu_info.VendorID = hashmap["vendor_id"];
+        cpu_info.Model_Name = hashmap["model name"];
+
+        try {
+            cpu_info.Physical_Cores = std::stoi(hashmap["cpu cores"].c_str());
+        } catch (const std::invalid_argument& ia) {
+            std::wcerr << "Invalid argument: " << ia.what() << '\n';
+        } catch (const std::out_of_range& oor) {
+            std::wcerr << "Out of Range error: " << oor.what() << '\n';
+        }
+        
+        cpu_info.Logical_Cores = (cpu_info.Flags.find("ht") != cpu_info.Flags.end()) ? cpu_info.Physical_Cores * 2 : cpu_info.Physical_Cores;
+
+        return std::make_shared<FCPUInfo>(cpu_info);
+    }
+
+    std::shared_ptr<FOSVerInfo> WineUtilities::get_linux_info()
+    {
+        std::string append;
+        if (is_wine_present())
+        {
+            append = "Z:";
+        }
+
+        FOSVerInfo os_info;
+        
+        std::ifstream file(append + "/etc/os-release");
+        std::unordered_map<HarmonyLinkLib::FString, HarmonyLinkLib::FString> hashmap;
+
+        if (file) {
+            std::string line;
+            while (std::getline(file, line)) {
+                std::istringstream lineStream(line);
+                std::string key, value;
+                if (std::getline(lineStream, key, '=')) {
+                    if (std::getline(lineStream, value)) {
+                        // Remove leading and trailing whitespace
+                        size_t firstNonSpace = value.find_first_not_of(" \t");
+                        size_t lastNonSpace = value.find_last_not_of(" \t");
+                        if (firstNonSpace != std::string::npos && lastNonSpace != std::string::npos) {
+                            value = value.substr(firstNonSpace, lastNonSpace - firstNonSpace + 1);
+                        } else {
+                            value.clear(); // If value is all whitespace, make it empty
+                        }
+
+                        // Check for double quotes and remove them
+                        if (!value.empty() && value.front() == '"' && value.back() == '"') {
+                            value = value.substr(1, value.length() - 2);
+                        }
+
+                        hashmap[key] = value;
+                    }
+                }
+            }
+            file.close();
+        }
+
+        // Now you can access the values using the keys:
+        os_info.name = hashmap["NAME"];
+        os_info.id = hashmap["ID"];
+        os_info.version_id = hashmap["VERSION_ID"];
+        os_info.version_codename = hashmap["VERSION_CODENAME"];
+        os_info.pretty_name = hashmap["PRETTY_NAME"];
+
+        try {
+            os_info.version = std::stoi(hashmap["VERSION"].c_str());
+        } catch (const std::invalid_argument& ia) {
+            std::cerr << "Invalid argument: " << ia.what() << '\n';
+            // Handle the error, perhaps by setting a default value or leaving the field unchanged
+        } catch (const std::out_of_range& oor) {
+            std::cerr << "Out of Range error: " << oor.what() << '\n';
+            // Handle the error, perhaps by setting a default value or leaving the field unchanged
+        }
+
+        return std::make_shared<FOSVerInfo>(os_info);
+    }
+
+    bool WineUtilities::is_wine_present()
+    {
+        static bool isWineCached = false; // Static variable to store the cached result
+        static bool isWine = false;       // Static variable to indicate if the caching has been done
+
+        if (!isWineCached)
+        {
+            // Only detect wine if force_detect_wine is true or if we haven't cached the result yet
+#ifdef BUILD_WINDOWS
+            std::wcout << "Detecting wine...\n";
+            bool HasFound = GetProcAddress(GetModuleHandle("ntdll.dll"), "wine_get_version") != nullptr;
+
+            if (!HasFound)
+                HasFound = GetProcAddress(GetModuleHandle("ntdll.dll"), "proton_get_version") != nullptr;
+
+            wprintf(L"wine %s found\n", HasFound ? L"has been" : L"not");
+
+            isWine = HasFound; // Cache the result
+#else
+            isWine = false; // In non-Windows builds, always set isWine to false
+#endif
+            isWineCached = true; // Indicate that the result is now cached
+        }
+
+        return isWine; // Return the cached result
+    }
+
+    bool WineUtilities::force_detect_wine_presence()
+    {
+        force_detect_wine = true;
+        return is_wine_present();
+    }
+}

HarmonyLinkLib/src/Platform/WineUtilities.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "Structs/FBattery.h"
+#include "Structs/FCPUInfo.h"
+#include "Structs/FOSVerInfo.h"
+
+namespace HarmonyLinkLib
+{
+    class WineUtilities
+    {
+    public:
+        static std::shared_ptr<FBattery> get_battery_status();
+
+        static std::shared_ptr<FCPUInfo> get_cpu_info();
+
+        /**
+         * @brief Retrieves Linux OS version information from a specified file.
+         * 
+         * This function parses a file (typically a Linux OS release file) at the given location
+         * to extract operating system version information. It reads key-value pairs from the file,
+         * processes them to handle whitespace and quotes, and then stores them in an FOSVerInfo
+         * structure. If the file location is invalid or the file cannot be opened, it returns an
+         * empty FOSVerInfo structure. Errors during parsing, such as invalid format or out of range 
+         * values, are handled with exception catching. In Windows builds where Wine is detected, 
+         * this function can use the file location 'Z:/etc/os-release' to retrieve the underlying 
+         * Linux system information.
+         * 
+         * @param file_location The location of the file containing OS version information.
+         * @return A shared pointer to a structure containing the parsed OS version information.
+         */
+        static std::shared_ptr<FOSVerInfo> get_linux_info();
+
+        /**
+         * @brief Detects the presence of Wine or Proton in Windows builds.
+         * 
+         * This function assesses if the application is running under Wine or Proton by
+         * querying specific functions in the 'ntdll.dll' module. It is only active in 
+         * Windows builds, returning false for non-Windows builds.
+         *
+         * @return bool True if Wine or Proton is detected, false otherwise.
+         */
+        static bool is_wine_present();
+
+        static bool force_detect_wine_presence();
+    };
+}

HarmonyLinkLib/src/Version.cpp

@@ -0,0 +1 @@
+#include "Version.h"

HarmonyLinkLib/src/dllmain.cpp

@@ -0,0 +1,49 @@
+// Copyright (C) 2024  Jordon Brooks
+
+#include <iostream>
+#include "Version.h"
+
+namespace HarmonyLinkLib
+{
+    void HarmonyLinkInit()
+    {
+        std::wcout << "HarmonyLink V" << version::ToString().c_str() << " Copyright (C) 2023 Jordon Brooks\n";
+    }
+}
+
+
+#if BUILD_WINDOWS
+#include <windows.h>
+
+// Standard DLL entry point
+BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpvReserved) {
+    switch (fdwReason) {
+    case DLL_PROCESS_ATTACH:
+        // Code to run when the DLL is loaded
+        HarmonyLinkLib::HarmonyLinkInit();
+        break;
+    case DLL_THREAD_ATTACH:
+        // Code to run when a thread is created during the DLL's lifetime
+    case DLL_THREAD_DETACH:
+        // Code to run when a thread ends normally.
+    case DLL_PROCESS_DETACH:
+        // Code to run when the DLL is unloaded
+    default:
+        break;
+    }
+    return TRUE; // Successful DLL_PROCESS_ATTACH.
+}
+#endif
+
+#if BUILD_UNIX
+__attribute__((constructor))
+static void onLibraryLoad() {
+    // Code to run when the library is loaded
+    HarmonyLinkLib::HarmonyLinkInit();
+}
+
+__attribute__((destructor))
+static void onLibraryUnload() {
+    // Code to run when the library is unloaded
+}
+#endif