From 389794f82f6526633853c405ec6825569ddece31 Mon Sep 17 00:00:00 2001 From: Jessica James Date: Thu, 13 May 2021 17:07:07 -0500 Subject: [PATCH] Initial commit from SVN --- .gitignore | 3 + Rx_TCPLink.sln | 28 ++ Rx_TCPLink/DiscordRpc.cpp | 149 ++++++++++ Rx_TCPLink/DiscordRpc.h | 29 ++ Rx_TCPLink/HWID.cpp | 148 ++++++++++ Rx_TCPLink/Main.cpp | 90 +++++++ Rx_TCPLink/Ping.cpp | 254 ++++++++++++++++++ Rx_TCPLink/Rx_TCPLink.c | 238 ++++++++++++++++ Rx_TCPLink/Rx_TCPLink.h | 33 +++ Rx_TCPLink/Rx_TCPLink.vcxproj | 80 ++++++ Rx_TCPLink/Rx_TCPLink.vcxproj.user | 11 + Rx_TCPLink/Screenshot.cpp | 165 ++++++++++++ Rx_TCPLink/UDKArray.h | 75 ++++++ Rx_TCPLink/Viewport.h | 105 ++++++++ Rx_TCPLink/WSAInitCleanup.cpp | 32 +++ .../win32-static/bin/send-presence.exe | Bin 0 -> 56832 bytes .../win32-static/include/discord_register.h | 26 ++ .../win32-static/include/discord_rpc.h | 87 ++++++ discord-rpc/win32-static/lib/discord-rpc.lib | Bin 0 -> 183366 bytes .../win64-static/bin/send-presence.exe | Bin 0 -> 68608 bytes .../win64-static/include/discord_register.h | 26 ++ .../win64-static/include/discord_rpc.h | 87 ++++++ discord-rpc/win64-static/lib/discord-rpc.lib | Bin 0 -> 264048 bytes 23 files changed, 1666 insertions(+) create mode 100644 .gitignore create mode 100644 Rx_TCPLink.sln create mode 100644 Rx_TCPLink/DiscordRpc.cpp create mode 100644 Rx_TCPLink/DiscordRpc.h create mode 100644 Rx_TCPLink/HWID.cpp create mode 100644 Rx_TCPLink/Main.cpp create mode 100644 Rx_TCPLink/Ping.cpp create mode 100644 Rx_TCPLink/Rx_TCPLink.c create mode 100644 Rx_TCPLink/Rx_TCPLink.h create mode 100644 Rx_TCPLink/Rx_TCPLink.vcxproj create mode 100644 Rx_TCPLink/Rx_TCPLink.vcxproj.user create mode 100644 Rx_TCPLink/Screenshot.cpp create mode 100644 Rx_TCPLink/UDKArray.h create mode 100644 Rx_TCPLink/Viewport.h create mode 100644 Rx_TCPLink/WSAInitCleanup.cpp create mode 100644 discord-rpc/win32-static/bin/send-presence.exe create mode 100644 discord-rpc/win32-static/include/discord_register.h create mode 100644 discord-rpc/win32-static/include/discord_rpc.h create mode 100644 discord-rpc/win32-static/lib/discord-rpc.lib create mode 100644 discord-rpc/win64-static/bin/send-presence.exe create mode 100644 discord-rpc/win64-static/include/discord_register.h create mode 100644 discord-rpc/win64-static/include/discord_rpc.h create mode 100644 discord-rpc/win64-static/lib/discord-rpc.lib diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..962f2c9 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +.vs/ +Debug/ +Release/ diff --git a/Rx_TCPLink.sln b/Rx_TCPLink.sln new file mode 100644 index 0000000..c17bfdc --- /dev/null +++ b/Rx_TCPLink.sln @@ -0,0 +1,28 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 15 +VisualStudioVersion = 15.0.26228.9 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "Rx_TCPLink", "Rx_TCPLink\Rx_TCPLink.vcxproj", "{988779E2-4B8D-4997-82B6-25BC4E0A705E}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Debug|x64.ActiveCfg = Debug|x64 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Debug|x64.Build.0 = Debug|x64 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Debug|x86.ActiveCfg = Debug|Win32 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Debug|x86.Build.0 = Debug|Win32 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Release|x64.ActiveCfg = Release|x64 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Release|x64.Build.0 = Release|x64 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Release|x86.ActiveCfg = Release|Win32 + {988779E2-4B8D-4997-82B6-25BC4E0A705E}.Release|x86.Build.0 = Release|Win32 + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Rx_TCPLink/DiscordRpc.cpp b/Rx_TCPLink/DiscordRpc.cpp new file mode 100644 index 0000000..5556901 --- /dev/null +++ b/Rx_TCPLink/DiscordRpc.cpp @@ -0,0 +1,149 @@ +#define _CRT_SECURE_NO_WARNINGS + +#include "DiscordRpc.h" +#include +#include +#include +#include "discord_rpc.h" + +static constexpr int GDI_TEAM_NUM = 0; +static constexpr int NOD_TEAM_NUM = 1; + +int64_t now_seconds() { + return std::chrono::duration_cast(std::chrono::system_clock::now().time_since_epoch()).count(); +} + +extern "C" __declspec(dllexport) void UpdateDiscordRPC(wchar_t* in_server_name, wchar_t* in_level_name, int in_player_count, int in_max_players, int in_team_num, int in_time_elapsed, int in_time_remaining, int in_is_firestorm, wchar_t* in_image_name) { + // Convert our input strings + char server_name[128]; + size_t server_name_length{}; + char level_name[128]; + size_t level_name_length{}; + char image_name[128]; + size_t image_name_length{}; + + server_name_length = std::wcstombs(server_name, in_server_name, sizeof(server_name)); + level_name_length = std::wcstombs(level_name, in_level_name, sizeof(level_name)); + image_name_length = std::wcstombs(image_name, in_image_name, sizeof(image_name)); + + // Populate our presence + DiscordRichPresence presence{}; + + // state + if (*level_name != '\0') { + // We're in a match + presence.state = level_name; + } + else { + // We're not in a level; we must be at the main menu + presence.state = "Main Menu"; + } + + // details, party info + if (*server_name != '\0') { + // We're in a multiplayer server + presence.details = server_name; + + presence.partySize = in_player_count; + presence.partyMax = in_max_players; + } + else { + // We're not in any server + if (strcmp(level_name, "Black Dawn") == 0) { + // We're playing campaign + presence.details = "Campaign"; + } + else if (*level_name != '\0') { + // We're playing skirmish + presence.details = "Singleplayer Skirmish"; + } + // else // we're sitting at the main menu + } + + if (in_is_firestorm == 0) { + presence.largeImageKey = "renegadex"; + presence.largeImageText = "Renegade X"; + + if (in_team_num == GDI_TEAM_NUM) { + presence.smallImageKey = "gdi"; + presence.smallImageText = "GDI"; + } + else if (in_team_num == NOD_TEAM_NUM) { + presence.smallImageKey = "nod"; + presence.smallImageText = "Nod"; + } + } + else { + presence.largeImageKey = "fs"; + presence.largeImageText = "Renegade X: Firestorm"; + + // For map-specfic images + if (*image_name != '\0') { + presence.largeImageKey = image_name; + } + + if (in_team_num == GDI_TEAM_NUM) { + presence.smallImageKey = "tsgdi"; + presence.smallImageText = "GDI"; + } + else if (in_team_num == NOD_TEAM_NUM) { + presence.smallImageKey = "tsnod"; + presence.smallImageText = "Nod"; + } + } + + + + // Discord client logic: + // If endTimestamp is present: display time remaining + + // If the match is over (negative in_time_remaining); don't display anything + if (presence.endTimestamp >= 0) { + presence.startTimestamp = now_seconds() - in_time_elapsed; + + // If it's a timed match, display the time remaining + if (in_time_remaining != 0) { + presence.endTimestamp = now_seconds() + in_time_remaining; + } + } + + // Update our presence + Discord_UpdatePresence(&presence); +} + +//typedef struct DiscordRichPresence { +// const char* state; /* max 128 bytes */ +// const char* details; /* max 128 bytes */ +// int64_t startTimestamp; +// int64_t endTimestamp; +// const char* largeImageKey; /* max 32 bytes */ +// const char* largeImageText; /* max 128 bytes */ +// const char* smallImageKey; /* max 32 bytes */ +// const char* smallImageText; /* max 128 bytes */ +// const char* partyId; /* max 128 bytes */ +// int partySize; +// int partyMax; +// const char* matchSecret; /* max 128 bytes */ +// const char* joinSecret; /* max 128 bytes */ +// const char* spectateSecret; /* max 128 bytes */ +// int8_t instance; +//} DiscordRichPresence; + +/*char buffer[256]; + DiscordRichPresence discordPresence; + memset(&discordPresence, 0, sizeof(discordPresence)); + discordPresence.state = "West of House"; + sprintf(buffer, "Frustration level: %d", FrustrationLevel); + discordPresence.details = buffer; + discordPresence.startTimestamp = StartTime; + discordPresence.endTimestamp = time(0) + 5 * 60; + discordPresence.largeImageKey = "canary-large"; + discordPresence.smallImageKey = "ptb-small"; + discordPresence.partyId = "party1234"; + discordPresence.partySize = 1; + discordPresence.partyMax = 6; + discordPresence.matchSecret = "xyzzy"; + discordPresence.joinSecret = "join"; + discordPresence.spectateSecret = "look"; + discordPresence.instance = 0; + Discord_UpdatePresence(&discordPresence);*/ \ No newline at end of file diff --git a/Rx_TCPLink/DiscordRpc.h b/Rx_TCPLink/DiscordRpc.h new file mode 100644 index 0000000..8fcbb6a --- /dev/null +++ b/Rx_TCPLink/DiscordRpc.h @@ -0,0 +1,29 @@ +/** + * Copyright (C) 2018 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#pragma once + +#ifdef __cplusplus +extern "C" { +#endif // __cplusplus + + __declspec(dllexport) void UpdateDiscordRPC(wchar_t* in_server_name, wchar_t* in_level_name, int in_player_count, int in_max_players, int in_team_num, int in_time_elapsed, int in_time_remaining, int is_in_firestorm, wchar_t* in_image_name); + +#ifdef __cplusplus +} +#endif // __cplusplus \ No newline at end of file diff --git a/Rx_TCPLink/HWID.cpp b/Rx_TCPLink/HWID.cpp new file mode 100644 index 0000000..2f1ad1d --- /dev/null +++ b/Rx_TCPLink/HWID.cpp @@ -0,0 +1,148 @@ +#define _WINSOCK_DEPRECATED_NO_WARNINGS +#include +#include +#include +#include +#include +#include +#include "UDKArray.h" + +static std::string s_hwid; + +struct HWID { + union { + uint64_t hwid; + struct { + uint32_t left; + uint32_t right; + }; + }; +} hwid; + +#pragma pack(push, 4) +struct ByteArrayWrapper { + UDKArray data; +}; +#pragma pack(pop) + +std::string GetSystemDriveGUID() { + char* system_drive; + char system_drive_mount_point[64]; + char system_drive_volume_name[64]; + char* system_drive_guid_start; + char* system_drive_guid_end; + + system_drive = getenv("SystemDrive"); + if (system_drive != NULL) { + if (GetVolumePathNameA(system_drive, system_drive_mount_point, sizeof(system_drive_mount_point))) { + if (GetVolumeNameForVolumeMountPointA(system_drive_mount_point, system_drive_volume_name, sizeof(system_drive_volume_name))) { + // Find start of guid + system_drive_guid_start = system_drive_volume_name; + while (*system_drive_guid_start != '\0') { + if (*system_drive_guid_start == '{') { + // Found start of guid; interate over '{' and break + ++system_drive_guid_start; + break; + } + + ++system_drive_guid_start; + } + + // Find end of guid + system_drive_guid_end = system_drive_guid_start; + while (*system_drive_guid_end != '\0') { + if (*system_drive_guid_end == '}') { + // Found end of guid; break + break; + } + + ++system_drive_guid_end; + } + + // Copy guid to out_guid + return std::string{ system_drive_guid_start, system_drive_guid_end }; + } + } + } + + return {}; +} + +void fill_mac_hwid() { + IP_ADAPTER_ADDRESSES addresses[32]; + PIP_ADAPTER_ADDRESSES node; + ULONG addresses_size = sizeof(addresses); + + if (GetAdaptersAddresses(AF_UNSPEC, 0, NULL, addresses, &addresses_size) == ERROR_SUCCESS) { + for (node = addresses; node != NULL; node = node->Next) { + if (node->PhysicalAddressLength > 0) { + static_assert(MAX_ADAPTER_ADDRESS_LENGTH <= sizeof(struct HWID), "HWID struct is not large enough to fit adapter physical address"); + memcpy(&hwid, node->PhysicalAddress, node->PhysicalAddressLength); + + if (hwid.hwid != 0) { + return; + } + } + } + } + + hwid.hwid = 0; +} + +/** Integer to string (hexadecimal) conversion tables */ + +const char hexadecimal_rep_table_upper[][3] = +{ + "00", "01", "02", "03", "04", "05", "06", "07", "08", "09", "0A", "0B", "0C", "0D", "0E", "0F", + "10", "11", "12", "13", "14", "15", "16", "17", "18", "19", "1A", "1B", "1C", "1D", "1E", "1F", + "20", "21", "22", "23", "24", "25", "26", "27", "28", "29", "2A", "2B", "2C", "2D", "2E", "2F", + "30", "31", "32", "33", "34", "35", "36", "37", "38", "39", "3A", "3B", "3C", "3D", "3E", "3F", + "40", "41", "42", "43", "44", "45", "46", "47", "48", "49", "4A", "4B", "4C", "4D", "4E", "4F", + "50", "51", "52", "53", "54", "55", "56", "57", "58", "59", "5A", "5B", "5C", "5D", "5E", "5F", + "60", "61", "62", "63", "64", "65", "66", "67", "68", "69", "6A", "6B", "6C", "6D", "6E", "6F", + "70", "71", "72", "73", "74", "75", "76", "77", "78", "79", "7A", "7B", "7C", "7D", "7E", "7F", + "80", "81", "82", "83", "84", "85", "86", "87", "88", "89", "8A", "8B", "8C", "8D", "8E", "8F", + "90", "91", "92", "93", "94", "95", "96", "97", "98", "99", "9A", "9B", "9C", "9D", "9E", "9F", + "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7", "A8", "A9", "AA", "AB", "AC", "AD", "AE", "AF", + "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7", "B8", "B9", "BA", "BB", "BC", "BD", "BE", "BF", + "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7", "C8", "C9", "CA", "CB", "CC", "CD", "CE", "CF", + "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7", "D8", "D9", "DA", "DB", "DC", "DD", "DE", "DF", + "E0", "E1", "E2", "E3", "E4", "E5", "E6", "E7", "E8", "E9", "EA", "EB", "EC", "ED", "EE", "EF", + "F0", "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "FA", "FB", "FC", "FD", "FE", "FF" +}; + +template +std::string to_hex(T in_integer) { + std::string result; + uint8_t* begin = reinterpret_cast(&in_integer); + uint8_t* itr = begin + sizeof(T); + + result.reserve(sizeof(in_integer) * 2); + while (itr != begin) { + --itr; + result += hexadecimal_rep_table_upper[*itr]; + } + + return result; +} + +extern "C" __declspec(dllexport) void c_token(ByteArrayWrapper* out_hwid) { + std::string hwid_str; + + // Try mac address + fill_mac_hwid(); + if (hwid.hwid != 0) { + hwid_str = 'm'; + hwid_str += to_hex(hwid.left) + to_hex(hwid.right); // keep this format so it matches old + } + else { + // Fallback to System Drive GUID + hwid_str = 'd'; + hwid_str += GetSystemDriveGUID(); + } + + // Return hwid_str through out_hwid + out_hwid->data.reserve(hwid_str.size()); + out_hwid->data.ArrayNum = hwid_str.size(); + memcpy(out_hwid->data.Data, hwid_str.data(), hwid_str.size()); +} diff --git a/Rx_TCPLink/Main.cpp b/Rx_TCPLink/Main.cpp new file mode 100644 index 0000000..c81a788 --- /dev/null +++ b/Rx_TCPLink/Main.cpp @@ -0,0 +1,90 @@ +#include +#include +#include +#include +#include +#include "discord_rpc.h" +#include "discord_register.h" +#include "Rx_TCPLink.h" +#include "DiscordRpc.h" +#include "Viewport.h" + +extern "C" ReallocFunctionPtrType g_realloc_function = nullptr; + +void* searchMemory(const std::vector& bytes) +{ + MODULEINFO mi; + + GetModuleInformation(GetCurrentProcess(), GetModuleHandle(nullptr), &mi, sizeof mi); + + byte* moduleHead = static_cast(mi.lpBaseOfDll); + byte* moduleTail = moduleHead + mi.SizeOfImage; + + byte* region = moduleHead; + + while (region < moduleTail) + { + MEMORY_BASIC_INFORMATION mbi; + + if (!VirtualQuery(region, &mbi, sizeof mbi)) + { + break; + } + + byte* regionTail = region + mbi.RegionSize; + + constexpr DWORD protectionFlags = PAGE_EXECUTE | PAGE_EXECUTE_READ | PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_WRITECOPY; + + if (mbi.State & MEM_COMMIT && !(mbi.Protect & PAGE_GUARD) && mbi.AllocationProtect & protectionFlags) + { + void* result = std::search(region, regionTail, bytes.begin(), bytes.end()); + + if (result != regionTail) + { + return result; + } + } + + region = regionTail; + } + + return nullptr; +} + +#pragma pack(push, 4) +struct FDLLBindInitData +{ + INT Version; + ReallocFunctionPtrType ReallocFunctionPtr; +}; +#pragma pack(pop) + +void initViewport() +{ +#if _WIN64 + const auto address = searchMemory({ + 0x48, 0x89, 0x5C, 0x24, 0x08, 0x48, 0x89, 0x6C, 0x24, 0x10, 0x48, 0x89, + 0x74, 0x24, 0x18, 0x57, 0x48, 0x83, 0xEC, 0x30, 0x33, 0xC0, 0x49, 0x8B, + 0xE8, 0x48, 0x8B, 0xFA, 0x48, 0x8B, 0xF1, 0x89, 0x42, 0x08, 0x39, 0x42, + 0x0C, 0x74, 0x19, 0x48, 0x8B, 0x0A, 0x89, 0x42, 0x0C, 0x48, 0x85, 0xC9, + 0x74, 0x0E, 0x44, 0x8D, 0x40, 0x08, 0x33, 0xD2, 0xE8, 0xA3, 0x5D, 0xC0 }); +#else + const auto address = searchMemory({ + 0x53, 0x56, 0x8B, 0x74, 0x24, 0x0C, 0x83, 0x7E, 0x08, 0x00, 0x57, 0x8B, + 0xD9, 0xC7, 0x46, 0x04, 0x00, 0x00, 0x00, 0x00, 0x74, 0x1C, 0x8B, 0x06, + 0xC7, 0x46, 0x08, 0x00, 0x00, 0x00, 0x00, 0x85, 0xC0, 0x74, 0x0F, 0x6A, + 0x08, 0x6A, 0x00, 0x50, 0xE8, 0x53, 0x75, 0xC6, 0xFF, 0x83, 0xC4, 0x0C, + 0x89, 0x06, 0x8B, 0x03, 0x8B, 0x50, 0x0C, 0x8B, 0xCB, 0xFF, 0xD2, 0x8B }); +#endif + + Viewport::setReadPixelsFunction(reinterpret_cast(address)); +} + +extern "C" __declspec(dllexport) void DLLBindInit(FDLLBindInitData* in_init_data) { + g_realloc_function = in_init_data->ReallocFunctionPtr; + + init_wsa(); + Discord_Initialize("482746941256499220", nullptr, 1, nullptr); + UpdateDiscordRPC(L"", L"", 0, 0, 0, 0, 0, 0, L""); + initViewport(); +} diff --git a/Rx_TCPLink/Ping.cpp b/Rx_TCPLink/Ping.cpp new file mode 100644 index 0000000..90709fb --- /dev/null +++ b/Rx_TCPLink/Ping.cpp @@ -0,0 +1,254 @@ +#define _WINSOCK_DEPRECATED_NO_WARNINGS +#define PIO_APC_ROUTINE_DEFINED +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +// Forward declarations and aliases +struct PingContext; +using request_map = std::unordered_map>; + +// Constants +constexpr int PING_IN_PROGRESS = -1; +constexpr int PING_FAILED = -2; + +unsigned char icmp_request_data[]{ "Renegade X Game Client Ping Data" }; +constexpr size_t icmp_request_data_length = sizeof(icmp_request_data) - 1; +constexpr DWORD icmp_reply_buffer_size = sizeof(ICMP_ECHO_REPLY) + icmp_request_data_length + 8 + sizeof(IO_STATUS_BLOCK); +constexpr DWORD icmp_timeout = 1000; // 1 second + +// Statics +std::atomic s_pings_in_progress{ 0 }; // Note, this is ALL ping requests in progress, not necessarily the ones in `s_pings` (and therefore, not necessarily contexts that still exist) +std::atomic s_ping_thread_active{ false }; +std::shared_ptr s_pings; +std::forward_list> s_pending_requests; +std::thread s_ping_thread; +//std::mutex s_pings_mutex; +std::mutex s_pending_requests_mutex; + +struct PingContext { + HANDLE icmp_handle{}; + IPAddr destination{}; + std::weak_ptr request_group; + std::unique_ptr reply_buffer; + std::atomic ping_time_milliseconds{ PING_IN_PROGRESS }; + + // Performs any single-run cleanup needed + void finish() { + // Cleanup handle + IcmpCloseHandle(icmp_handle); + icmp_handle = nullptr; + + // Mark no longer in progress + --s_pings_in_progress; + } + + PingContext() { + ++s_pings_in_progress; + } + + ~PingContext() { + if (icmp_handle != nullptr) { + IcmpCloseHandle(icmp_handle); + --s_pings_in_progress; + } + } +}; + +IPAddr parse_address(const wchar_t* in_str) { + IN_ADDR buffer_addr{}; + InetPtonW(AF_INET, in_str, &buffer_addr); + + return buffer_addr.S_un.S_addr; +} + +void WINAPI icmp_ping_callback(void* in_context, PIO_STATUS_BLOCK in_status_block, ULONG) { + std::unique_ptr> weak_context{ static_cast*>(in_context) }; + auto strong_context = weak_context->lock(); + + if (strong_context == nullptr) { + // Context has been destroyed already; s_pings must have changed + return; + } + + // Cleanup handle + strong_context->finish(); + + if (NT_ERROR(in_status_block->Status)) { + // Ping failed somehow; set status to error + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + // Verify ping reply size + if (in_status_block->Information < icmp_request_data_length) { + // Ping did not reply with same data as sent; set status to error + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + DWORD reply_count = IcmpParseReplies(strong_context->reply_buffer.get(), icmp_reply_buffer_size); + if (reply_count <= 0) { + // No response was received; this should never happen since one of the above checks would certainly have been hit + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + ICMP_ECHO_REPLY* replies = reinterpret_cast(strong_context->reply_buffer.get()); + for (DWORD index = 0; index < reply_count; ++index) { // reply_count should never be anything other than 1, but hey, whatever + ICMP_ECHO_REPLY& reply = replies[index]; + + // Verify success + if (reply.Status != IP_SUCCESS) { + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + // Verify reply size; this is probably redundant, but hey whatever + if (reply.DataSize != icmp_request_data_length) { + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + // Verify ping data patches + if (std::memcmp(icmp_request_data, reply.Data, icmp_request_data_length) != 0) { + strong_context->ping_time_milliseconds = PING_FAILED; + return; + } + + // Ping request successful; set it + strong_context->ping_time_milliseconds = reply.RoundTripTime; + } +} + +void process_pending_requests() { + std::unique_lock lock{ s_pending_requests_mutex }; + // Loop until there are no pings in progress + while (s_pings_in_progress != 0) { + // Process pending any requests in the queue + while (!s_pending_requests.empty()) { + // Pop front pending request + auto pending_request = s_pending_requests.front().lock(); + s_pending_requests.pop_front(); + + if (pending_request != nullptr) { + // Kick off ICMP request + IcmpSendEcho2( + pending_request->icmp_handle, + nullptr, // event + &icmp_ping_callback, + new std::weak_ptr(pending_request), + pending_request->destination, + icmp_request_data, + icmp_request_data_length, + nullptr, // options + pending_request->reply_buffer.get(), + icmp_reply_buffer_size, + icmp_timeout); + } + } + + // Process any thread alerts / ICMP callbacks + lock.unlock(); + SleepEx(10, TRUE); + lock.lock(); + } + + s_ping_thread_active = false; +} + +void queue_pending_request(std::weak_ptr in_pending_request) { + std::lock_guard lock{ s_pending_requests_mutex }; + s_pending_requests.push_front(std::move(in_pending_request)); + + // Start thread if necessary + if (!s_ping_thread_active) { + // Join any existing thread + if (s_ping_thread.joinable()) { + s_ping_thread.join(); + } + + // Mark processing active + s_ping_thread_active = true; + + // Spin up thread + s_ping_thread = std::thread(&process_pending_requests); + } +} + +extern "C" __declspec(dllexport) bool start_ping_request(const wchar_t* in_str) { + // Parse address to ping + IPAddr destination_address = parse_address(in_str); + if (destination_address == 0) { + // Failed to parse + return false; + } + + // Get ICMP handle to send request + HANDLE icmp_handle = IcmpCreateFile(); + if (icmp_handle == INVALID_HANDLE_VALUE) { + // Failed to open handle for ICMP requests + return false; + } + + // Build request context + auto context = std::make_shared(); + context->icmp_handle = icmp_handle; + context->destination = destination_address; + context->reply_buffer = std::make_unique(icmp_reply_buffer_size); + { + //std::lock_guard guard{ s_pings_mutex }; + + if (s_pings == nullptr) { + s_pings = std::make_shared(); + } + + context->request_group = s_pings; + s_pings->emplace(in_str, context); + } + + // Queue request context + queue_pending_request(context); + + return true; +} + +extern "C" __declspec(dllexport) int get_ping(const wchar_t* in_str) { + //std::lock_guard guard{ s_pings_mutex }; + + // Safety check that s_pings actually exists + if (s_pings == nullptr) { + // Ping request does not exist + return PING_FAILED; + } + + // Search for IP in ping list + auto itr = s_pings->find(in_str); + if (itr == s_pings->end()) { + // Ping request does not exist + return PING_FAILED; + } + + // This is a massive hack, but we need to be able to join the processing thread when we're done to prevent a shutdown crash + if (!s_ping_thread_active && s_ping_thread.joinable()) { + s_ping_thread.join(); + } + + return itr->second->ping_time_milliseconds; +} + +extern "C" __declspec(dllexport) void clear_pings() { + //std::lock_guard guard{ s_pings_mutex }; + s_pings = nullptr; + + if (!s_ping_thread_active && s_ping_thread.joinable()) { + s_ping_thread.join(); + } +} diff --git a/Rx_TCPLink/Rx_TCPLink.c b/Rx_TCPLink/Rx_TCPLink.c new file mode 100644 index 0000000..14a4956 --- /dev/null +++ b/Rx_TCPLink/Rx_TCPLink.c @@ -0,0 +1,238 @@ +/** + * Copyright (C) 2016-2018 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#include +#include +#include + +#define _WINSOCK_DEPRECATED_NO_WARNINGS +#include +#include +#include + + /** Relative path to the launcher executable */ +#define LAUNCHER_PATH "..\\..\\..\\Launcher\\Renegade X Launcher.exe" + +bool init_wsa_success; + +#pragma pack(push, 4) +struct socket_t { + uint64_t sock; +} s_socket; + +struct AcceptedSocket +{ + uint64_t sock; + int32_t addr; + int32_t port; +} accepted_socket; +#pragma pack(pop) + +void init_wsa() +{ + WSADATA wsadata; + init_wsa_success = WSAStartup(WINSOCK_VERSION, &wsadata); +} + +void cleanup_wsa() +{ + if (init_wsa_success) + WSACleanup(); +} + +__declspec(dllexport) struct socket_t* c_socket() +{ + s_socket.sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); + return &s_socket; +} + +// since UDK only supports IPv4, just return the IP address as an integer (or 0 on failure). +/*int32_t c_resolve(unsigned char *hostname) +{ + struct hostent *host_entry; + IN_ADDR address; + + host_entry = gethostbyname(hostname); + if (host_entry == NULL) + return 0; + + memcpy(&address, host_entry->h_addr_list[0], host_entry->h_length); + + return address.s_addr; +}*/ + +struct sockaddr_in helper_make_sockaddr_in(int32_t in_address, int32_t in_port) +{ + struct sockaddr_in address; + IN_ADDR in_addr; + + memset(&address, 0, sizeof(address)); + + in_addr.s_addr = htonl(in_address); + address.sin_addr = in_addr; + address.sin_family = AF_INET; + address.sin_port = htons(in_port); + + return address; +} + +// Binds to in_port, or fails +__declspec(dllexport) int32_t c_bind(struct socket_t* in_socket, int32_t in_port) +{ + struct sockaddr_in address; + + address = helper_make_sockaddr_in(INADDR_ANY, in_port); + + if (bind(in_socket->sock, (struct sockaddr *) &address, sizeof(address)) == 0) + return in_port; + + return 0; +} + +// Binds to in_port, or the next available +__declspec(dllexport) int32_t c_bind_next(struct socket_t* in_socket, int32_t in_port) +{ + struct sockaddr_in address; + + address = helper_make_sockaddr_in(INADDR_ANY, in_port); + + while (true) + { + if (bind(in_socket->sock, (struct sockaddr *) &address, sizeof(address)) == 0) + return in_port; + + if (WSAGetLastError() != WSAEADDRINUSE) + return 0; + + address.sin_port = htons(++in_port); + } +} + +// Binds to any port +__declspec(dllexport) int32_t c_bind_any(struct socket_t* in_socket) +{ + struct sockaddr_in address; + + address = helper_make_sockaddr_in(INADDR_ANY, 0); + + if (bind(in_socket->sock, (struct sockaddr *) &address, sizeof(address)) == 0) + return ntohs(address.sin_port); + + return 0; +} + +__declspec(dllexport) int32_t c_listen(struct socket_t* in_socket) +{ + return listen(in_socket->sock, SOMAXCONN); +} + +__declspec(dllexport) struct AcceptedSocket *c_accept(struct socket_t* in_socket) +{ + struct sockaddr addr; + int size; + + size = sizeof(addr); + accepted_socket.sock = accept(in_socket->sock, &addr, &size); + + if (accepted_socket.sock != INVALID_SOCKET) + { + accepted_socket.addr = ((struct sockaddr_in *) &addr)->sin_addr.s_addr; + accepted_socket.port = ((struct sockaddr_in *) &addr)->sin_port; + } + + return &accepted_socket; +} + +__declspec(dllexport) int32_t c_connect(struct socket_t* in_socket, int32_t in_address, int32_t in_port) +{ + struct sockaddr_in address; + + address = helper_make_sockaddr_in(in_address, in_port); + + return connect(in_socket->sock, (struct sockaddr *) &address, sizeof(address)); +} + +__declspec(dllexport) int32_t c_close(struct socket_t* in_socket) +{ + return closesocket(in_socket->sock); +} + +__declspec(dllexport) int32_t c_recv(struct socket_t* in_socket, unsigned char *out_buffer, int32_t in_buffer_size) +{ + return recv(in_socket->sock, out_buffer, in_buffer_size, 0); +} + +__declspec(dllexport) int32_t c_send(struct socket_t* in_socket, unsigned char *in_buffer, int32_t in_buffer_size) +{ + return send(in_socket->sock, in_buffer, in_buffer_size, 0); +} + +__declspec(dllexport) int32_t c_set_blocking(struct socket_t* in_socket, int32_t in_value) +{ + unsigned long block_mode; + block_mode = in_value == 0 ? 1 : 0; + return ioctlsocket(in_socket->sock, FIONBIO, &block_mode); +} + +__declspec(dllexport) int32_t c_get_last_error() +{ + return GetLastError(); +} + +__declspec(dllexport) int32_t c_check_status(struct socket_t* in_socket) +{ + fd_set set_read, set_err; + struct timeval time_val; + int value; + + time_val.tv_sec = 0; + time_val.tv_usec = 0; + FD_ZERO(&set_read); + FD_ZERO(&set_err); + FD_SET(in_socket->sock, &set_read); + FD_SET(in_socket->sock, &set_err); + + // check for success + value = select(in_socket->sock + 1, NULL, &set_read, &set_err, &time_val); + if (value > 0) // socket can be written to + { + if (FD_ISSET(in_socket->sock, &set_read)) + return 1; + if (FD_ISSET(in_socket->sock, &set_err)) + return -1; + } + + return value; +} + +__declspec(dllexport) bool UpdateGame() { + STARTUPINFOA startupInfo; + PROCESS_INFORMATION processInformation; + + memset(&startupInfo, 0, sizeof(startupInfo)); + memset(&processInformation, 0, sizeof(processInformation)); + + // Create process + if (!CreateProcessA(LAUNCHER_PATH, NULL, NULL, NULL, false, 0, NULL, NULL, &startupInfo, &processInformation)) { + return false; + } + + // Process successfully created; exit the application so that patching doesn't fail horribly + exit(EXIT_SUCCESS); + return true; // unreachable +} diff --git a/Rx_TCPLink/Rx_TCPLink.h b/Rx_TCPLink/Rx_TCPLink.h new file mode 100644 index 0000000..7e4866b --- /dev/null +++ b/Rx_TCPLink/Rx_TCPLink.h @@ -0,0 +1,33 @@ +/** + * Copyright (C) 2016 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#if defined __cplusplus +extern "C" +{ +#endif // __cplusplus + + void init_wsa(); + void cleanup_wsa(); + + typedef void* (*ReallocFunctionPtrType)(void* Original, DWORD Count, DWORD Alignment); + extern ReallocFunctionPtrType g_realloc_function; + +#if defined __cplusplus +} + +#endif //__cplusplus \ No newline at end of file diff --git a/Rx_TCPLink/Rx_TCPLink.vcxproj b/Rx_TCPLink/Rx_TCPLink.vcxproj new file mode 100644 index 0000000..48948fd --- /dev/null +++ b/Rx_TCPLink/Rx_TCPLink.vcxproj @@ -0,0 +1,80 @@ + + + + + Debug + Win32 + + + Release + Win32 + + + Debug + x64 + + + Release + x64 + + + + {988779E2-4B8D-4997-82B6-25BC4E0A705E} + Rx_TCPLink + 10.0 + + + + DynamicLibrary + false + v142 + Unicode + + + + + + + + + + + + + + Level3 + Disabled + MultiThreaded + Default + ..\discord-rpc\win64-static\include;%(AdditionalIncludeDirectories) + ..\discord-rpc\win32-static\include;%(AdditionalIncludeDirectories) + + + true + ..\discord-rpc\win64-static\lib;%(AdditionalLibraryDirectories) + ..\discord-rpc\win32-static\lib;%(AdditionalLibraryDirectories) + Ws2_32.lib;iphlpapi.lib;discord-rpc.lib;%(AdditionalDependencies) + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Rx_TCPLink/Rx_TCPLink.vcxproj.user b/Rx_TCPLink/Rx_TCPLink.vcxproj.user new file mode 100644 index 0000000..c66f12b --- /dev/null +++ b/Rx_TCPLink/Rx_TCPLink.vcxproj.user @@ -0,0 +1,11 @@ + + + + D:\RenX\SVN\UDK_Uncooked\Binaries\Win64\UDK.exe + WindowsLocalDebugger + + + D:\RenX\SVN\UDK_Uncooked\Binaries\Win32\UDK.exe + WindowsLocalDebugger + + \ No newline at end of file diff --git a/Rx_TCPLink/Screenshot.cpp b/Rx_TCPLink/Screenshot.cpp new file mode 100644 index 0000000..c5d94b7 --- /dev/null +++ b/Rx_TCPLink/Screenshot.cpp @@ -0,0 +1,165 @@ +/** + * Copyright (C) 2019 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#include +#include +#include +#include +#include "Viewport.h" + +Viewport::ReadPixelsFunctionType Viewport::readPixelsFunction = nullptr; + +/** Filename related constants */ +static constexpr wchar_t prefix[]{ L"ScreenCapture " }; +static constexpr size_t prefix_length = sizeof(prefix) / sizeof(wchar_t) - 1; +static constexpr wchar_t extension[]{ L".jpg" }; +static constexpr size_t extension_length = sizeof(extension) / sizeof(wchar_t) - 1; +static constexpr size_t max_date_length = FILENAME_MAX - prefix_length - extension_length; + +#pragma pack(push, 4) +struct ScreenCapture +{ + UDKArray data; + + // For pushing data to captures + template + void push(const T& in_data) { + // Expand capture as necessary + int required_size = data.ArrayNum + sizeof(T); + if (required_size >= data.ArrayMax) { + // Expand to minimum required size, or double array size, whichever is larger + data.Reallocate(max(required_size, data.ArrayMax * 2)); + } + + // Copy data to capture + std::memcpy(data.Data + data.ArrayNum, &in_data, sizeof(T)); + data.ArrayNum += sizeof(T); + } + + // For popping from captures + template + T pop() { + T result{}; + if (sizeof(T) > data.ArrayNum) { + return result; + } + + // Copy item to result + uint8_t* item_begin = data.Data + data.ArrayNum - sizeof(T); + std::memcpy(&result, item_begin, sizeof(T)); + + // Pop item + data.ArrayNum -= sizeof(T); + + // Return result + return result; + } +}; +#pragma pack(pop) + +extern "C" __declspec(dllexport) void take_ss(Viewport::DllBindReference* viewport, ScreenCapture* result) +{ + // Read in screenshot data from UDK + viewport->value->readPixels(result->data, { 6, 0, 1, 16000.0F }); + int sizeX = viewport->value->getSizeX(); + int sizeY = viewport->value->getSizeY(); + + // Import screenCapture data into CImage + CImage outputImage; + outputImage.Create(sizeX, sizeY, 32); + for (int row = 0; row < sizeY; ++row) + { + const void* screenCaptureRowAddress = &result->data[row * sizeX * sizeof(UDKColor)]; + void* outputRowAddress = outputImage.GetPixelAddress(0, row); + memcpy(outputRowAddress, screenCaptureRowAddress, sizeX * 4); + } + + // Save JPEG image data to memory stream + auto stream = SHCreateMemStream(NULL, 0); + outputImage.Save(stream, Gdiplus::ImageFormatJPEG); + stream->Seek({}, STREAM_SEEK_SET, 0); + + // Get stream size + STATSTG stream_stat{}; + stream->Stat(&stream_stat, STATFLAG::STATFLAG_NONAME); + auto stream_size = stream_stat.cbSize.QuadPart; + + // Read data from stream into buffer + result->data.ArrayNum = stream_size; + stream->Read(result->data.Data, result->data.ArrayMax, nullptr); + stream->Release(); +} + +static_assert(sizeof(UDKColor) == 4, "UDKColor size != 4"); + +extern "C" __declspec(dllexport) void write_ss(ScreenCapture* screenCapture) +{ + // Get current date + auto currentTime = std::time(nullptr); + auto currentTm = localtime(¤tTime); + wchar_t timeString[max_date_length + 1]; + std::wcsftime(timeString, max_date_length, L"%F - %H-%M-%S", currentTm); + + // Build filename + std::wstring filename{ prefix }; + filename += timeString; + filename += extension; + + // Write to file + std::ofstream file{ filename, std::ios::binary }; + file.write(reinterpret_cast(screenCapture->data.Data), screenCapture->data.ArrayNum); +} + +constexpr size_t byte_buffer_size = 256; + +/** + * Copies data from a dynamic UDK byte array to a static UDK byte array + * + * @param out_destination Byte buffer to copy data to + * @param in_source Byte array to copy data from + * @param in_offset Position of in_source to start copying from + * @return Total number of bytes copied (will never exceed byte_buffer_size) + */ +extern "C" __declspec(dllexport) int copy_array_to_buffer(uint8_t* out_destination, ScreenCapture* in_source, int in_offset) { + // Sanity check length and offset + if (in_offset < 0 + || in_source == nullptr + || in_source->data.ArrayNum <= in_offset + || out_destination == nullptr) { + return 0; + } + + size_t length = min(byte_buffer_size, in_source->data.ArrayNum - in_offset); // Remaining bytes in array or buffer size, whichever is smaller + std::memcpy(out_destination, in_source->data.Data + in_offset, length); + return length; +} + +/** static shit */ + +uint8_t* s_cap_buffer = nullptr; +ScreenCapture* s_capture = nullptr; + +extern "C" __declspec(dllexport) void set_cap(uint8_t* buffer, ScreenCapture* screenCapture) { + s_cap_buffer = buffer; + s_capture = screenCapture; +} + +extern "C" __declspec(dllexport) int read_cap(int in_offset) { + int result = copy_array_to_buffer(s_cap_buffer, s_capture, in_offset); + return result; +} diff --git a/Rx_TCPLink/UDKArray.h b/Rx_TCPLink/UDKArray.h new file mode 100644 index 0000000..3896353 --- /dev/null +++ b/Rx_TCPLink/UDKArray.h @@ -0,0 +1,75 @@ +/** + * Copyright (C) 2019 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#pragma once + +#include +#include "Rx_TCPLink.h" + +#pragma pack(push, 4) +template +struct UDKArray +{ + void Reallocate(int NewNum) + { + ArrayMax = NewNum; + Data = static_cast((*g_realloc_function)(Data, ArrayMax * sizeof(DataT), 8)); + } + + void reserve(int in_size) { + if (in_size > ArrayMax) { + Reallocate(in_size); + } + } + + DataT& operator[](const int index) + { + return Data[index]; + } + + const DataT& operator[](const int index) const + { + return Data[index]; + } + + void push_back(const DataT& in_item) { + if (ArrayNum >= ArrayMax) { + Reallocate(max(ArrayNum * 2, 8)); + } + + Data[ArrayNum] = in_item; + ++ArrayNum; + } + + void pop_back() { + --ArrayNum; + } + + DataT& back() const { + return Data[ArrayNum - 1]; + } + + DataT& front() const { + return Data[0]; + } + + DataT* Data; + int ArrayNum; + int ArrayMax; +}; +#pragma pack(pop) diff --git a/Rx_TCPLink/Viewport.h b/Rx_TCPLink/Viewport.h new file mode 100644 index 0000000..a5ae54f --- /dev/null +++ b/Rx_TCPLink/Viewport.h @@ -0,0 +1,105 @@ +/** + * Copyright (C) 2019 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#pragma once + +#include +#include "UDKArray.h" + +#pragma pack(push, 4) +struct UDKColor +{ + union { + struct { + uint8_t b, g, r, a; + }; + + uint8_t bytes[4]; + uint32_t uint; + int32_t sint; + }; +}; + +static_assert(sizeof(UDKColor) == 4, "UDKColor has unexpected extra data; must be exactly 4"); + +struct ReadPixelsMetadata +{ + int cubeFace; + int compresssionMode; + int convertLinearToGamma; + float depth; +}; + +class Viewport +{ +public: + int readPixels(UDKArray& result, ReadPixelsMetadata metadata) + { + int value = readPixels(reinterpret_cast&>(result), metadata); + + // expand to bytes + result.ArrayNum *= sizeof(UDKColor); + result.ArrayMax *= sizeof(UDKColor); + return value; + } + + int readPixels(UDKArray& result, ReadPixelsMetadata metadata) + { + return readPixelsFunction(this, result, metadata); + } + + int getSizeX() const + { + return callVirtualFunction<2, int>(); + } + + int getSizeY() const + { + return callVirtualFunction<3, int>(); + } + + using ReadPixelsFunctionType = int(__thiscall*)(void*, UDKArray&, ReadPixelsMetadata); + + static void setReadPixelsFunction(const ReadPixelsFunctionType value) + { + readPixelsFunction = value; + } + + static ReadPixelsFunctionType readPixelsFunction; + + struct DllBindReference + { + Viewport* value; + }; + +private: + template ReturnType callVirtualFunction(ArgumentList... arguments) + { + using FunctionType = ReturnType(__thiscall*)(void*, ArgumentList...); + const auto p = (*reinterpret_cast(this))[Index]; + return p(this, arguments...); + } + + template ReturnType callVirtualFunction(ArgumentList... arguments) const + { + using FunctionType = ReturnType(__thiscall*)(const void*, ArgumentList...); + const auto p = (*reinterpret_cast(this))[Index]; + return p(this, arguments...); + } +}; +#pragma pack(pop) diff --git a/Rx_TCPLink/WSAInitCleanup.cpp b/Rx_TCPLink/WSAInitCleanup.cpp new file mode 100644 index 0000000..43e6162 --- /dev/null +++ b/Rx_TCPLink/WSAInitCleanup.cpp @@ -0,0 +1,32 @@ +/** + * Copyright (C) 2016 Jessica James. + * + * Permission to use, copy, modify, and/or distribute this software for any + * purpose with or without fee is hereby granted, provided that the above + * copyright notice and this permission notice appear in all copies. + * + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY + * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION + * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN + * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. + * + * Written by Jessica James + */ + +#include "Rx_TCPLink.h" + +class WSAInitCleanup +{ +public: + WSAInitCleanup() + { + init_wsa(); + } + ~WSAInitCleanup() + { + cleanup_wsa(); + } +} _wsa_init_cleanup; diff --git a/discord-rpc/win32-static/bin/send-presence.exe b/discord-rpc/win32-static/bin/send-presence.exe new file mode 100644 index 0000000000000000000000000000000000000000..03ef5e59826a53088e96f6c4f3c4a1a387a61841 GIT binary patch literal 56832 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 CVOVhh literal 0 HcmV?d00001 diff --git a/discord-rpc/win32-static/include/discord_register.h b/discord-rpc/win32-static/include/discord_register.h new file mode 100644 index 0000000..16fb42f --- /dev/null +++ b/discord-rpc/win32-static/include/discord_register.h @@ -0,0 +1,26 @@ +#pragma once + +#if defined(DISCORD_DYNAMIC_LIB) +#if defined(_WIN32) +#if defined(DISCORD_BUILDING_SDK) +#define DISCORD_EXPORT __declspec(dllexport) +#else +#define DISCORD_EXPORT __declspec(dllimport) +#endif +#else +#define DISCORD_EXPORT __attribute__((visibility("default"))) +#endif +#else +#define DISCORD_EXPORT +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +DISCORD_EXPORT void Discord_Register(const char* applicationId, const char* command); +DISCORD_EXPORT void Discord_RegisterSteamGame(const char* applicationId, const char* steamId); + +#ifdef __cplusplus +} +#endif diff --git a/discord-rpc/win32-static/include/discord_rpc.h b/discord-rpc/win32-static/include/discord_rpc.h new file mode 100644 index 0000000..3e1441e --- /dev/null +++ b/discord-rpc/win32-static/include/discord_rpc.h @@ -0,0 +1,87 @@ +#pragma once +#include + +// clang-format off + +#if defined(DISCORD_DYNAMIC_LIB) +# if defined(_WIN32) +# if defined(DISCORD_BUILDING_SDK) +# define DISCORD_EXPORT __declspec(dllexport) +# else +# define DISCORD_EXPORT __declspec(dllimport) +# endif +# else +# define DISCORD_EXPORT __attribute__((visibility("default"))) +# endif +#else +# define DISCORD_EXPORT +#endif + +// clang-format on + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct DiscordRichPresence { + const char* state; /* max 128 bytes */ + const char* details; /* max 128 bytes */ + int64_t startTimestamp; + int64_t endTimestamp; + const char* largeImageKey; /* max 32 bytes */ + const char* largeImageText; /* max 128 bytes */ + const char* smallImageKey; /* max 32 bytes */ + const char* smallImageText; /* max 128 bytes */ + const char* partyId; /* max 128 bytes */ + int partySize; + int partyMax; + const char* matchSecret; /* max 128 bytes */ + const char* joinSecret; /* max 128 bytes */ + const char* spectateSecret; /* max 128 bytes */ + int8_t instance; +} DiscordRichPresence; + +typedef struct DiscordUser { + const char* userId; + const char* username; + const char* discriminator; + const char* avatar; +} DiscordUser; + +typedef struct DiscordEventHandlers { + void (*ready)(const DiscordUser* request); + void (*disconnected)(int errorCode, const char* message); + void (*errored)(int errorCode, const char* message); + void (*joinGame)(const char* joinSecret); + void (*spectateGame)(const char* spectateSecret); + void (*joinRequest)(const DiscordUser* request); +} DiscordEventHandlers; + +#define DISCORD_REPLY_NO 0 +#define DISCORD_REPLY_YES 1 +#define DISCORD_REPLY_IGNORE 2 + +DISCORD_EXPORT void Discord_Initialize(const char* applicationId, + DiscordEventHandlers* handlers, + int autoRegister, + const char* optionalSteamId); +DISCORD_EXPORT void Discord_Shutdown(void); + +/* checks for incoming messages, dispatches callbacks */ +DISCORD_EXPORT void Discord_RunCallbacks(void); + +/* If you disable the lib starting its own io thread, you'll need to call this from your own */ +#ifdef DISCORD_DISABLE_IO_THREAD +DISCORD_EXPORT void Discord_UpdateConnection(void); +#endif + +DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence); +DISCORD_EXPORT void Discord_ClearPresence(void); + +DISCORD_EXPORT void Discord_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply); + +DISCORD_EXPORT void Discord_UpdateHandlers(DiscordEventHandlers* handlers); + +#ifdef __cplusplus +} /* extern "C" */ +#endif diff --git a/discord-rpc/win32-static/lib/discord-rpc.lib b/discord-rpc/win32-static/lib/discord-rpc.lib new file mode 100644 index 0000000000000000000000000000000000000000..fe90a6a69111ccd721460b1cfb3af23041c363ab GIT binary patch literal 183366 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 literal 0 HcmV?d00001 diff --git a/discord-rpc/win64-static/bin/send-presence.exe b/discord-rpc/win64-static/bin/send-presence.exe new file mode 100644 index 0000000000000000000000000000000000000000..7f8d495935ba0a3cbe606c4e5785ec3678dcb230 GIT binary patch literal 68608 zcmeFa4SZC^)jxjovSbN_yHQqy3M`P+&JITWztWYFpacr})%jz*aYe=0)BDv=YQ>e5u~Js1Yp$Y`wqlnYnj&6Tp{# zp0>aL=kt%UGk509nKNh3oH=u5?%cxLcL+&>ASC0TstQ6qLi%&C-!J${5QG6k_YV-B z?R#WceS-JMu=#7ssw@?i>+h^wxz4g`WqJ8}pXD1RmP&uQrL5fIx^13i-TKufqtnt- zGd0vB*Dil}U7EF7|F_!zWb-OKFPt~Fsf>lTrg9dJZ}PElTvIW^A?wFBtwFdhZEW*U zgqP-xXU~`BjcZzqXLa7OW(qIO%Vp1V%T}$SI(oOL$Snw~A214!z4@ox^}H@&xX>?g zfFSHd%1gu@L3rv>{FqqOfoAh~q9F8PNwH9911E`@_)8Lsx9f$pvPk7f^nl>B6p9L~ z-xh=}itI@iI;f)RWMQk3612Z?vaku!@DV|{Nl%LlHyss(Y&>@$|KYfFVUHl};7y57 zjmAg&N;diMRQ?0}5JA*-tsRK5KZ_s~kFH$3(zj9&?r|asIE88Ww+sK`{u~gW(Hu-@ z@l&N}NCtv8<+P`$pj zfD(kh^s`HY>vI`gcywh|LUNX3JO z!RVr(VJLnXt{ZybBBX>*H4h*hLBk9XKyZ!G>R7%`-;RY;Un;NfNu9o?2Yb_JYgNrp zJpqjS7HEIKJ?lfNBJE&eg5V7q+<4lbfMz@QO+?_?KkB|myrVvuvsjW_3PTQ~)X;gW zWNYw`d>{yR;NXO_#^>CTB-l=% z($|(H3C?;Fe>|MV1A}$eU^L%3;;~2$JO29d*CY z97^f6VV1R@l!f?6qiVk6$1K&C>NUPHnSQc1Tz4M%977iwKEwx)VBV+1YviAZve2oK@ewAI5Kj-1t?gP zRP%R#6l;nUnxAO_=*tA!08rI%2n<&?5Z*b%P~+1;F3Aru=1aE2iuZn$mUm`403mHZ zNWHWozW==P0r@yEegZl=*8^j0sIi!y|98s2?ectymHv!!$5JlIgGmbdGBXxI4$)bC zCHW(->@-R893$%K{}WJ}0!Zq97d0|%7$tqe8k}|<{iZ00YqIbNHJ)T)CnChJ8if0y zb{Ti9OcsJjB3am)Y10J38WV*1j{~$etOOTQ7{!)&hM_@mt@$3v?aV{bDAzbY`s_mbFiIzVrrh~=RaH*V z&p(Ev8R0mcCI!8jMkzQy)8q}hGBdn*w9H#byt7L3MJeRVT&%I;L28NIuA~AFMlkUh z>}{6hlag#y%}-Kx;GlKI@}=?pdo|Rr5b9!7q3r)uRlV{d!j~-t4yjTzh6zX)ymF%? zp8|3z(3+r{C!vDcuqZY5s0AZ`H+YAU|BcTO@R7d*DS;{VY|zzEZ$kOe&~=5TRVXue z2!cyCT#I1>9WuX90T^JBLJwsEKu`+U(5hh%)LIv)lMR1WIh<8BpMXWeu!7z- ztosbNAi&dFGQy~Y9Toga!|Xu(H(I<1@!x9k;<$K49Ly%fdD)uGYT#?C$*e;lDEmhM zIYt;Yl1A8j_afYWkhsvOOu4aV=8?F}*m$zFb|!;HN`SoJ>1FK+&$TCfV_f3i#CmFy z8K_GK8Z zT)*XtrN4Cj)o98UFvDl!+7?^{rjta&Qf1 zFsWTNKLb-7Biu-8;ts@{ASwxx?8+=68L&Q2jKm;;04`R|?}94bY&ho>7k4?uY|O(`(Aab0 z@-8vENqO-hikrqi17N1J&WX2##YJj!+v?DXhETVLoL zRQikC*C+l?3U1A;kh|riDP%$UXL~~hCYRh&T3RX&ts#~RPPwStX)}>cChk8s)MG2^ z689d+OgP^z-PkG}e@_~5)MKk_!wezWUh)L%_Q3FGc3M+JoI(?Pr4ejW4A(&>lEg)= zV0NQX4F{7Xxj|}B21_FXb=Oki7D^cLN2#GBU3awP-!>p{bWaK1lyJO3g4$2tGbhpP(EZ zH(}<(YZ;KqrzP2Ai4(c^wsN5#!jvTNZvoeqnwWsigax_-)w9v@KGu|wX$a#MN|s~@ z-XI<$#Ec%jY8FD;>}-ai+N(Dk1!_iL)%*z|(y@M@VGSI#H*)#3NP&H8s#%*(`<9WA zSao@jpGh^}2TG(M2dGv3m?#50lh}>Q(xvGNZr)_2^IZ>KIHfGf|PI0fm<^+!# zCJ_Idq|ZZX*XPl~=okMLQ!j4BVRt}uvYAq(A3K*M#3YIpi6-QV>4wvuBtbNJGwot} z+Fw{45J-OmaUkE1p{bf(961vL<-6#+2L?ab&A3y%wDaBcs72(Mw_uTTA$olcicSQC z7rj?3$*(BqZop`Mk$elD7a$AxLvgaz0Ypo(7vOmS_odLonU5kxse}VYhA7T5dPW?@ zFf>R>4Kxo^CT~-Ii&*nKo=O9oha`!$dnhBc#Ke$3i3cD(5<|KRDazohAf-&sqx=@% zHyJ|zDk)S3WbgZy0ntMY(Gj96rR`z(@dd*6mB?^$N`P*w9$)kwW6*#64eE7t?#iYk#LRAPy%WS~~b z-6lVzbOS0mA4#;G*HOPhi)Ih-R1)$u~$-s?i=Q zl_aT+oa%g{Awh_wG#TatTyQ-w-v2kEz_9l<3bbww8lJ;rv*CC6r9WttHO}QL?qGJi z6tjQoHTwq|eoY4K9}5uu;~e10$cCXp>w`c1_TiVmrt}+~9@B>@;$BnD39;rNP%CMe z@g#Yu6ljDM#Y`Qj>K)&SDTZ4Rht=bN!8B1de-BU6T`jAn?F~Z75h&9?N*6k%hD$d{ z@&U|_Q>COfT2NS|vID|PKggGIT3|J0v-zx4ypJp{nhNX;zrSxtN>G|eNzhL3qBW{(O}}ZfLYF$^0%0LW=Y0?rAcf*I3We|F_`>sN~8d_$!ma=Uto%# zxn^1Tv^C0)2`n4EPui2sRyQJr#W0^PaL#uwa4vK%l0r{s?wY8o^~J4dm1`3~ayn=t zTFm8cXXXxMkTQCdg}=|-MWJliOza>TtSxF`35!W6Vc^yLzzEZKlQGFRQZ>&43#5EQ zO>Tl9KC~Sf%JF^#o%VG=E9Ny=Am4>lx9#m0*c|W&ngQ4x5SsElCdz$e#L$%G-i3d= zOM`{~Ern{0)xZ&S@9_pp>hWmhk6}Evh>OCIL3bPCXog!6fZY`=>B4ij)Ld%$HYbKC(26zx2TD1HTCCZQXDQGC^mh;N zr;rgt)YP_$HFr`D&BbZSn4aasG5cHGo7@j-a*|6_#o7D87UcvctNU0_qNt{zO>+77_L@4Zp;#zU9b4XY* zU^+Fz#}w%U);Q&ZLBrh+3}g(jIlvjza5@O*Emy?pt|pX@%bBlp$E0y5l7jKx{eOr% zt-f)XP+pye`3W{)mXj^my*UkRM&Sk;%_(d`0mlHuW+(>sfMNNE7y!Q^?Oc1t5APqk zF#T`v3mTvpL30CD0X|@5iJXlPq$@DfT}M>2Ilmv{B^eVwh{xYS*bfN<8axI9jImk! zKLXW-33(DKMGdl61N8DS(A0D5u>}%UGx~*-1vJc-i^nsD=pOPR1E*dKh5aGxWwgSKuGk7N@zlE-Ot1rz@quBg} ze)Qcf)t>jQB^keydFc)*&JQqIhGtnL`DNvA?~{`-3_6pvibhcFm|aCFByXaY$!*Ga z096Py=}4IGHu#Bri`Qqwp^17Ta+8|)cMp!vL&L_->T2I zAvP7{H^enz236Uk3GI;qRB>M^zoAFHydBT4i?w43Ysc4O_E_)sy!XJDYfmYVM%%N5 z9-{4;MfC-y42__R#F};{kZJel)4J^0T4seXXIK&9UfFQ*Jp@5ES<#vjGm7~GBuSx= zgsxKB@1g9hlPoE1GQ(2Ju`o+474aQjnNN11N2m-Yy43(zUR*;Ho&R>|#AH@(LR{@9 zYN&Qr%o{ZL08h0Klr$8fv@$|*J8FkfpLTE(QU3wT5SvMkzKb|=246ysY?z#%L^=6U ziM$yJfsPb!S=i{H#>_K%lG+O8+TC zM;^J`m&WZkwV75g-L|kNX3=1F&vxc?(=2bPH(*LFMQpTGkB-A1x!<>DW_w3;V`*%W zWT&yPU$bY?YBiO;Rg9PJH0#az{; zBRb&-UY$8gl82OHEh#$17Y;h>(*Wnn2}hD#aaSr{owzHOr&be1O^cOH?x|HdFeBQC+O@rM1!kKkRz!CXYBkEw@wE@Ym5M zPV`BmLl3UxuVd?(9PHBeUeAb>7Qdc(0h`&{dgkM|qU#w2(b#(ChOs0+Y&~;oB3sW` z-=_7<*SE*UVjsjmZ#|fT+#rqD>+RM z!AWW;Cz+J88NZ0j)*NnO{Q- zSx<6~q35zCIYGt3X$fFi_r{+e==>Byt}_=QjUl5~KJE<#Tlxa&^SUeA`TR~m?r_TK zPTL$~VaTKTo9A@*@;4vy*n;gC)6Cx-w4Ya1Pau-uZz>EuxO)IxT+jayc;fumUk2ae zkHA6lU&rBd%HOTN7Wiy)HA>iHZ(>N2j2_#A9Xdr1hS4l{@CMB>c_n#b{@=|Oso7}( zsTeyRaPKbIjZueeA9`pi$bcrAWmL^6@p-iW1w(Nb%8;!YEpvjWV=n$sRd>)7KY;CL zkiGd}DJ#=sWz0JTn_)|gaXkco$O0*}<|o)^+(ooCyQgYy5jZq9LD|0oH;5bB=cYo8 zRFjiz@l=m|TxoPFF&1W)I8 zAeEwNmI)5fhgr115*f$VqOW7|`7Zu_h<_LG56(JwifD4bj#5h)XyJz_wVXxWDpFS= z%8H5rg}>fC6#s6=^ez^4k3nh$q9E79$UVu-Pd+tnM0^Jf zfY;sxOT=1?9dz0;rD6fXprIA1DE7o#kfET2RcqR}C@LHFP)1P7(3T({z0Tm?qaawg zUJ5P1zrs_>=64CY4e=Suy0!Jnie0_6D3br}@NhI1LvADY+T4VF219w~@~#nKf>fk-SyhZ*$H}?PPlH!(7H# z2{5X8+SZt!8-h4w88ktsIB26R&L4OAeq>(mdZGvIMqinKI6g^`(`xanw!!>Ko5f20 z8PEV=hS6rkcgT$o7&1@?Hi$O@DvLoq$DtVhd58mbe+@OZ!qXfRPz^ck5TCEbt%&a; zwU2ay*{Q`HH1TJ15?U-o{Ml)pq{Rw#)O_W7jcd>gMmN6!5Pb@ zBaR)42s*sxjE_)$GL+i%Kpe{99Ob80PA#ESqbUE#z;BB~`SE5FmC&e9krTJRlnv*` zB%m>34SZO9BZro8r;(^HnlEnF2&q_{EezsdnMITEDOepL~)=O`8jUywc) z@dph3&Hzs+Z5aa9ypUU}OeS)P=D?KiB17=a#yLkk=NW47=L`};7fy$+92(<2o)_ZHX2-AJS<^2=;aPG*(x%}ED~^UX;Y zuW>M|@#jFOkAYcKBRZm(AB$rAkDGsB;X}XR;E-zG%u6x0n-P}{FSbW*=4TP55ovMB zX=fo=Y)(PZr_kHVsezPf*ui`LVh&*&5l2Ha{O>eEPXUQ)K8`1yx?i&#%r*LdM6+K6=&FB1!VWZ z!A|m2H8%izHDR$}d{r?P4RMBMCt|+}tdy{g7czea!$%2%=FS;FPPC}z`vFT+cCnKm zlnWE~qNFg8l0?y%b$8KL2%do2#=xO1u)Kp&(@)AjxI(jVu(y`v z0kqP|WX76|D4FdVYmO0X`VyIEqO3`blGy=sM)?%|sR@#5K7TjSOa}`?=2wu*s0O7v zM?#yhf;h?=#2Ud`pp&ol{XM|J$i7u0duklXB(L!#m#_+nvpUH~iR6VyjwAUtj0euy zbwsj6B%?cuRr4rTKE%cnJP$(_fo2%6G}vN(p|@yvR$D*Cozh%D#~K_sbA&ld{>UXC z+P6qZsrJZ<6q=?=Q()fS=MrbMx@%iEZKEANNdG-5Yq1w+FE=U96Y%^%RoQvpoz-9 z&VNAQK^F9Q1r*N-QZ=LO*ZM{hUcSOa3w=|U$5zjzmfce%*z4N*+PthSfQW6EowLnZSyKB z9jeI;BNqf%jTnUN_%4t`l2!8$fRPoGahCCMLVw0zP7bTU#e~X|e=B6e5U>gd*-eJ` zH!;nM&DPW6bB2DzK?t}5-mkZiL+;+S^;TdI)6rL~`>~4;=a}J7$c7k@t9L*0!{-R1 zmE zsRjR<{mfHFq^Rb{PynJkpPe>f`P=ONpu>ipSU8b2H1 zB*^Jrd8WymKhs#1u{*)}{4J2k`bqe4impZ{5kHMVQ^`&*N>HT9IXR(oDjwpA*XfZt zIjiHy@p5u3@#NTv9Kh<-?D$I5$R|2i5HT{RWge%+u>c!R+UXoeH?#c1G#AqVTZFmgZkl|5jMNbriAlb1_gm@Vn!H4CIoK71II$;ToKH zq61)Sp<8HxhmzB&)FyZYtAXNCDF`&7+DB0XqFBVxwEg{|L;x_oKx}q}?mZ{v!wun^ zf!<`DXRqFjz8gq~@U79_8{w*(6uDt{g8VW%2Je+1&nr97aSn)tv(7|(gjjS%3`9=? z-@V5SI-YECR`2VWlDKy+AHEUaEJ-e4)lID45?38up81loYPhQ|FER+#9YuA=dXmzo zE|u4Y@)(0fT9sIy>_S6flV8(ROR-T%`3b@cr_^RRSbt0%%wb^i5`b53^X43f#?qc~ zR-#ax(MHU%7D5~3W7$P;o(re>elxwA5giEqU3GYY1EYe#af%U#6H-0-2mJ79lj2~F zoUAu;6l>$lSv*#GA`p|(Bpi~QDjO>eE0wcS~3}%e{o&_X< zF?6yLCzsjb6zq1*r%LC8vu;VA#yC5n`kp9fqn$O(jhbnwiLMKmbtBqA-8d~;d(Kgp z+&~8>Sm*57G#s&B7JSbu&FWs^P!o3+dfYc1;a^!XD@K?>G_R+wnF-Ze|+YG)yr%{Xrxm7Atn1p)X8{e zQEtNiFx~~TFt%9Yl`kCq`2`ui8BnubbW+An_75ubT_3G7%UPGr>vD8OhDWWQ0nYQ` z1kv>mXI)-2H@T@`GJHI+8gg1_!3`_2foR#ONvMOkIc7Q$xHGew=nWh!x`O_Uw@0j8 zgSPe5pgS|^as}{u_^N=Hc`drhgPtnSW)tozs zMAiI5BtV_UtH5HKWEll~l8sY=u}YuiFZh{KL{EkL?<*TVcP>>U+0v*b;8AON1 z7%M45)QZ;}|JU2CX~ToGjAHGc#A+tqSD3Zw?8{XRYxZX%DW*?%9HH%|JQ^GAYYdT{FVyypr8HmNqK-`J}^$3|D+(4ul8Hmpy)C|OXS=$*5 z3_=3n1|nYS;g7Hnz2XeW6ZoUshXnS;_MxMHG!}0q@9x>e z>0aul*9!Hks2gqiY$yR%rfxo_PL*e8{D(RFD#AI~j z@k+MBaAqsO-vv9I`MY99I$RMw{asrVdKwC&_(;G=JmZ^2rpgrZ(1)BjU1m;?l6O4_ z#yVFsWx_PJyK@==i5F1WYqMlcpF{W30=gKJ4cYbbWuCL?j_B|=1@4sue`?@fF9!Z4 z;x=Cku*rjyU;qg}DAqajFkxqkcRyBhJ1}~ItS8NhDDcQq9c&d9_#&Eb1rSlGpg zl5eAjCz<>o^rm#t6}`thGnq3)HkAC9(COY|5BGgw$o=d0V)|ho=FSeQqMoHqPThSR z(!Iw}Z`{=}G3M&9MqM4l9d)^EpXB6MavndgX#%U_0ngy*cw*UQjt*@%;R}4d&Zw`~ z^-uVE4^c-_o4K#|U((j03sDDz*s9#YYCDEkyrS=W_4beBb$-n^KK@FsZ3{K``rYu? zeF=B#F}CQ$B^gxr8|dk;>OmdG#5>-Dnx9Mj(gb(=!9D1_c(>n|lz0CgVEK>8`;D+- zb$J)x`}fKFp~bokEP*Qm@_t~+e?;ETz~T0ofcd;-^0!eIW2Txh&BZl(fcpjrhuD`Vr&ZF9D-(AW_m zNH5J{v@5#r7T8<*0fYv&JwW@h*b!yh1Cl($g2P*w^JZjk7{K3$4&7!{t|3pJe4B;6 zn-~NPJDu7LdjuQwP9thhi4uU_(xpTI9n0zY=HUN3?U}}m+N-t)ZSB#XEmvs|d!Nr~ zabu$$?|M<^Z1l!F1T1cP!Zsd2b(h3*vRhuDcHykifEfRmfZ=& zDNF3I2+oQSFQJ~dknegT9dfe3 zb1e?VIU((SKJ1-E_eoO4y{XPRoG+lg+5@;3Bb^R6{Dq$-V{iKYcMgaO#7@71pMkSR zbfy=_YG`CeI~5EWPKdClgab}u%_kTYQgCu6qjSpiM^u%cuW+MI+=d1e9`%4*KJBdj zeO~d41dKisYo4T-)=$eAVR5I2OgI=+lTXmvsUZ|*kADA_cmV?~eAU;pkF~VeX{75s zFf|*LWMH*RF|6?imPR-OZ{fXcR2v5nN#i8C_$d`{exrDQCXPQ!@?w_Y8L(SRLwrjZ;3E)0T9?x&2cG zYPJ$xl|0BS(r$1<+NzDbVO;vDKstZ4R=ylOP+iUK;22Lz+L^lM|)DZ z{Zq#@QRq$N_D^>`kRVj{13ROHha5VkNF0hYZV90o&=eq!15HaLXtaD<5)Qs;u+x$~ zp=pMtjrGC&cNQ?F4Z?j_LsKuglG+28QY#06f4mg&D_Sfu(x>_W&e2`NIDm3^uhH4i ziIz9;mbdGzjBB~hjknNLp6m)Gqv<#v$jC}?C!LAba20B`22V3Mqs^VxhZ1i@yHcE? z0=->Ew5xCY=~?IpoMNXd3>u{E7kMAvOsX<8>RO!cb8hcu;l#Hc|Elaw9=A(076DzQkTI!Z95<9{v^G=3w<)=s;7!-QN|` z2z|-Z(0K#IgBXt{Xmaz0OMb=K5P{q@_8c*>(F^&|c?0=~A2AvZVvqa^kmxu#FLedr z3XQuaisDTjgDXUXt_}B6R5v|!ZzxFsPrdnJ)_I&y$a36c`uKJbkMtf~Mb@s$*%|O? zP!{8D4(o7an11>v1)6~}(xQwdX+fT{LBg&r%cFi9qnCNR-~2=^y+6h*vbZ>*_vq?5 zUV}yz#w9L>6LI_43)U%|>wPeg#8O~P=Xi9Um;CKL3Sy6G4@GXRY~;^_%9C$gDFK~;LFKOLXt zG(x~4%i@L+h8B&Ss+&U7taW{$lc5Bm{D>L|7|zT#B}THjszwe+gM3|1A)p)*?*KGG zGMSnq21Vt~bKxDjFS+5v8_Jrwe04F|xbSXI@yhAesJdLbF1#BRE>cQ>B-QS`@J^E2 zL$3yReKb} zN8X$Q*kt|a?kVid;ohj^>!e@;x$ia@q+og^2{MOMtSM4(3u*_3P%>WQqIUp;IN#K3 ztwM)1+4*{QA~|{=@fvC_F0Jlj_kEwn%Mnhi6m;6@fO4@@G_jW`vT@I{2`$_&e2sr_ zf!4&?r8{ur+GNW{Q4(JWOX8CUstnj3jl9R+dT00BI>mGWMbjlyV2f4o&+*9Q_w}cF zavY}S0=$=wTO;g+bXE!nDGw}fH;Y%RfyZAq4Jy(ITRNt~|8nNB51S)q}3(Ntg+ z)3LMxqlf|EGn&1Im{7saSkbBX*dL!l=^pF_SW*)`vH~%%)9anIQp91@e1}6@ zEP6tcMfoc`)>LTMK81kwWzdaHhE`u1y-16-jnh~foHGFL=z3n%IfU0u=sjK7`ot>> zx0mDi^am3a zG9|n1rNN@lq+wDwZki2Nbg`S%ytqpgiz)e-?YuG(yJLA9tzvCA3eoBz?tVd2lG@aZ z(yvD2Q@{xt#l6Pri?{fv5P88Q_OdeDHGy0C>iF=&4uJGFM+R13yu&v}BAE})us6@J zV#Eu?2|sQg(wd`u6FXdtJ2ej2=n)*y!_7)fxZCJLJFXu}mJ-l0a-rQT7n<diY)I2CUpu7yjJKzv3<#it%KIbK|H z4xsffmd1%v4h}hD7&bd`LjlOAWUSX<0%`AC5tTT(j^B&bcE8`PQ?=GVDHa`rs0Zu! zV4~81vlF;I4E~d(I2L2Tfi=sZ#RB|tq{}LfWnvhy_c7_63H?@6`7Bt5!-Vdz{<_32 zV5AG~ivHmGkL7|&<{b&vIRo#(?nrdkyziSb*(yHt9S!VT2%Xz6p`HCJ z`}h}4w%<2TD^(Ec|6S-fS7?qhJv6WgulAsPq;ax!>%z%-_svD2#~yoZ5DE>SJpR5R zpIhh<92>t)KuaPwVmHT=)2#O}I@^`!#4t^Q7Z9ze!4@vO2rz0GrCy@+2h@<~HGS5< zbO$x=0i2DC4;NloY zg8Zy6#&BKaFb~}~W(H(~62!}=WMeA0#ehd0g zq55LpeG>}vn>LP(HN3Sa>r}{GDp@{gG7hLV;3Ek@vh9y_w-#{#$x$Y7y3l62Ul^^o zYgnCui|N}kAw*YhsCo!o`s0Qqy_dEfBt#`X<7Bs3i(9w!W>bqSE^3b)_9vlfL<4;k z0rp9h26t{NmCo^{OdjP=bv}aw{A@@u+Qf&R1Di;4eiO${Mwg4;lY_Li`sR?d{al0l zaSU!o=%yc{4eroV41}8&!(Bk5W$Pe@dFwT3?|}Hawtc`dw(W~7ckUa9R=9EwK{}QI zZh;2Z3!^*#^u6(-!e_!RPykGkMo-Qu$Pp$q^z$N3j!xoRHk4+M2vVRO{v0>GHB<1XdJ0z8YH;osYOih1EskE(-^SA+3J|zJPjSKy-=$r7Rp_pZ|Yq71UIV5v+euYtb+;56Qq+( zU&hpN?*b2YU2VEYj>)}CpX_Ug+qhv#Pg7|z+unI;J-X?ciaP?5V?K~3jZ5z6A+?82` zhju`B2;ehYy9BGcJVCsqEVtt7NPKy3mnSrGC&G_Fsin7&t%W%IEr@T7P@9(R{BW56nG)0k%wT}Y@qgEU$==AN%i&v1mSFWE7jTWBpx7!xU8mKap2-b)=Ba<8k6mvbJ6c;4Gvtz zwdNR}I_=1rJlwZ%vZcydg8|myAMD9#04z4~FtHUdwu-e+5^R6K@=QV$%Ota}^Fvyg zqN7u^j_!PgCy+oirJ%1__p?q~BISH0smDmI(h|j!KRvd@oo!JPK|SexwnnMN7b~aR zeP4?$Pxv*uSf13QTKu8fVNPQ(PwIO&JRNS_4(4vBwLY#@R3OZFaR%$GB8+;B_9};d z(eJY8#V(o&8^7MFj4iVK|HLAT-N!9|{vwMw_{EDXjW!CfzJkaZoq>keAlXYcPV=m4 zz+nXUJrDqFBP9+*FSzB0?(eRJu1jCfv;6K2>SMl!z{++_VPW<~A|AapOt)!7b4C?9wW_ zes4=Q{y_(Cfezl{@CIigD8j$RQr;Gme?sWCY-JmrR%b66;&ApLDTr@eIiQg+5QCdc z?4r`(CJTATApW{z2#abWEI=1ZM0+@DFR?=jRw?w@nravj`R6$>QRoT_0hv;0VX+jvRth~(Oix(b+wk$kd7uFo!#5|==PV?0;E+2Il<(BYeym}^Bz{Ihb0^UC9#P){(a7(c!TAkz_-T6W@;W$r)fV=B8b40y&RH#c zik)g3@F~UnNPW^oL*5U54NdgE8l@7sQqXYb?L-h0{cg}%Jo+-Z<0a>0=?*wV>4T1r z%f1}MKBgEl?4;s4a?lsY4|bmoxn((-1u-(^S;e?}d$mU9zWNxMvZ%a=N8V`dtA)TG z6F5e{6}<>OyTn3zm|P_mG5aIDjT-MVs$!Qq$7wV0{#qJRPGkLbFlkAPq4&q`NuVVG zFdekgP9y14>;U64mzdJIOUxi8pf=e9mlzFRa*55gD|CL9?P15?*38=yPjo_9hDb1v)(j>ZB^r6(Lx(XX8ytk5*)+NSdzds?0-HN9dQ_>l-QTzV zWi1_aTxdk0YJX;Fz%#%??4w(@z&8n7-N@M5w|=jNmCKiw&H5{zUd~f#)umqS%w+WT zWanU8c>j5jKs>EgSp`xsuT=CLAYyygqmM7#qarcbhhz4^i;gy5#xE*fjbSdyw zH(gBAUy^4UrKCere(HuSDQ^YFIJsjbamFH}Qj3qu!d@otacq3h_XVj;Xj%q+qXtD; zUJyx98PerHCO^Fzn$K<%?%B|ICpBvr&}rM!4(0~0@2JCu#vZJywQmw-b49*0(-%JQ- zD@GgzuWTy+vK@1@u`_$2N9^^4^huvIu8@8=f2D8Vc4&R z6(0(6)ozJ?Dd;uA`Z|5;Z2>8yA{+$2ZVK_{h;qXq#*`_T21O*r-Cv81uzVP4lU#W! z7AOI=kN^GV=|ucVjoq zh5b4u8=5ir0DYqur^7vgFfe?NfbqR$Whd(rUtd&$6!;#9`*)%*BpEl4QCH%S_P5}7 zr-cql1uVF1eEbXRHu_{kFK;=WXPC#%Ywv+USYLz*SotPg8YD%sAq-oFA6j*QGzbW0 z7qta?pMQ-kB{$sp0wW8bTA82e;P1eCvDZ;Yc!vLujHmM?71shvTR)@sUC@MCbWj(C zB$_9>pXFjE0}Nu~a@F~gsn1+^a0HYDv1TwB$|8*bK?LtdbR&5eu^EcIxu6&t6-_q( zG#@EYpE-@5(9E6KmgBeL6y_Yj=>gg~iG6KI3>-ljthr!*;9?XE;^4@TBs7 z!r6Z6T@srj1H$bGNeWgh#c7QmoV9_jt8zBB9~IBvb(ko6)A)MlBAPyM)L-JeVr25U z=t7tI^n+w}<0C0rB-@ppFu0``Py~M<0Jq}bigEwS%|y&GDr8ZDKZJIH=DrQziHLpZ z5<7OJNKCOWUKy|#9D&2NiMR_y^ML5_ctnoRLzETwjfz3ukjI2$8qfsJTIT@2sSsA4 zcf`>MZjDV#WhiN{Dgj?`Y4zPoe01B#`tbVUOWGw(Irz|A!%k09YvEigwR zxvQQeoz3?0dzdHbdbBBIRY8Na%CF(WN*J3bm1pVwj_5WfOl)Zw_%Hui>PyCOi}F9$ zQV*dNJ_Hm6<1lM8?ZJt`jX*>D+|iklQ*{M;NSS^fJ(yBXDw$tE&+vbm9vmLj&pStL zJ~Fd=ntL^`gCFsWSM>aCy156X#TtOscCEUp?-lK-Zoh$SCkNS5&1iA8|C-*m)Rin6 z>Y2;wyNtZQzIHizLpAcqii6#RlP{$gPL&4UwUqYjE)8zJvH`{HYmyhe(vO%5Q0XClBz3APs!-3cf%Sn)2#zm{JTK0VGZpIwag7`Mv@D8qiO zs<~lIbU@8zi6ln1D@nG9A<-0WI~S5=j)P+Oq6O_$F|7(2V@9%Lo?FJUBjRAJ+CIbPg3kh^s^a1sOv3^l*h8Ij3jznx+gZG_hPLAq78euzsT}AQ0O3N(nazeoWB>*{FmIvDmGGSg z1j)O?1Ch~p2P#atw&ypIBx{&lT+9jV4bmn%>ep3^I;1>@k`S0{q`;@D zKSg-~?TZ+c?<1hxVaO#@_RplPmo|2uL^|~+_4W5L%#by#M3R%Uti);z7~Fq=xp$x~ z+$D+6q^)^5N$`KbuK&z##8+M~pe(On+-nFRv$pkl>P5U#P-m#ZvvLnAP@Je0>`2C4 zsRNa9{GqR{RT+tB8-nq%tu*D& zKz)+aOIYtg+F43_k)??bha-1Nvbpsh=rDW*LO!t10W5)zsW~ls5VuFz$s0JxoK3vX9z3l)iSDtT0B8Hvobjhf-!eb&C;g^j4pTklS4a^aJnc)a zIpH6GVdX+ zOxg(KD+7^WYsJ>D=)xkqLBq%7@#ioU;WxQ4e4!m{6{h*Ir-RKKXr48&bSmHt+hlRl zUE~&zyabcQIkubAi75kXDZGm64HYCSZ5J^l-SDWMZ)bCe`^GS?i*?}&*xG_*AKqCw z#&-5_=Nb5+-uI=8`tqRZ9Mz`r zHDtIjhVd0{-17$#@I9go8Wgv}bwTg+@;>M_pR?CP(k`692OD;g+PVNu1E%i3x#JKm~dH1FHdFAAFnatC0B!dq$t&Lj%Wo(kpsWw`zWYSz*9%-d9d0co}Jx z)lwkqS=0#JN0r001_`A-j%O9jHBa7%Y0rVm2lf&enw@oMNfpmmG+FDh=PMhgK)SG@C6mzt;}SP-6iP2a8}LD%y#)Lom#Z<&#TgP zQ}R*O{8P$7WAmiI>P$OG!0ps@pK39^s|L2HEi4i5qZm0pbNj1NU zCpcQiQhX1OhYBtHxrLtH78EnVb7hfih}+yI$<`pjLqmVSGy)Gcy|Vm9Xe4ar8fvLd z3`$A5(1yo*=@C7T*EgsWz$m;Jz(QNN5qGkuxoJ*Nvu;I=acTn514zJ~?cg5nlNDSKKoJ~hC+pT0&NJ9i3nnov+znX_K4dVnkaP>a3iouTgU&H-KO4p%lTUN0 z`!gmUbVRaz=*Y-G)}KgiqrqLa6VCcJvM3L+0ZAVYxhPVb9#_x+-0;(mOvpF}m1;gk zIY2U5@6AvL%Vj{Z9tB|`g)-2=SnC&dQN%(6=GzQ)Z3|_h*NbqgELDSfDZ~<;^^a1m zOz3Ot5LLzzSu!ty6>l+IG(|X`L*FczPb^l=@4-xfmxzW7@WF$Fs}Q@yhZ`v_QKfyU zQq<;9&3zDs9!NcZ=Em?aLmLezoY!fiI&fPq0(MU>%`a3CpAJDjo!4S>=0t6>PVk?T zRyilbow?o4X6Lu|@!46*@V5u*Ye3b24aWlYG#qfv1E~Vo%b_$3d+PgpK(D56_^ zRaNUc{5J(QWhDErlO;=Nd&i}<@8JIW4I*AVay*vcOJSCIcB67PxE4D%q^-+BgDZ2X zdE@Uw5P{vAPx=y!_FtUgbnu|b@@4H=SH z4t$XzgTjzNB{ekm#{c-$@ZZAm|C!}q3I8FM!|?C9I{qnF!+#hmG)6W0Gh|5D&;%Nc zoxeqP{2o=v@NqU3z)_I|I=tRsRCWO5d}D$yjZN3oVGrR%mv$~*+m>T;B9ZV~lsB3C z#~is8cv!*$R!88hmOq^IM94gEs-9146WE!Xjes}QQ1zl4uW1}U+&PSLfE)d9qT^>7 zx>604D6qF|m`7e+FR(R}_yl~U&4yMy(s0}U(JE)53ooR(WV|E!QAxS4%(?wsS$T=a zxxK60SF+aKugxW&amj{_ZAmzy`?1sSTjTC`T0ZIOcY6D|871X@TdUmd>UV-ENbw2S z)-Ji#6)fzQTY`6d5?t_iH%!#IQXp+5s#KkUmgKCisjBD-8nS?KO1Mvg;LDy;+$Rxt z;7_Tb;0D8{-EcmhgBj^UjxEDi>3e?t(vXkdxO^g<+% zBlie$>uJ@C^UfgT?fmYonYLC&8c|f(4Wfc~DB}LN`ZA1(DDxP~IK};M46G_|HauO< zdDU$A8Dh}0EbGRqc?5A&l^4ho+N6dzEmFTW936tU!EMUyGr5mHS2k=yi9n07*>EQ! zkXhlpTd@QUEAiyJHqc^eHq1s8nhBrj^dd&1*iIJDR_;?Hg++71WaL5D(A3QS)T~?> z?`qa+_Pdb%O6+$M`@Mzz4q?A0_InA|t(tX~{l3P27qj#y*sqWMmckxav$9$Im+bdh z_Pd<@cCg=E--p=mXY7~bpUL9$+3$a|-(BqYJx0S}_S?i#>RCLI z#gp0ZX!dLBON)(Y({&agjM?96M_e+ZQs_a92%&SnpGM7tc8agzaf#w*t9toQHJJH6 zo{loR2+l?RNFK+iwsd~-di1$-u?9;u1I9}5pFAEd&z|4LGx8WMik7FrI|%+@Tz(6W zvvR-ZaYpwZ9;YiyI-f#ZD_>0Ip9MYIGpl2D?3v+rae8+U>>4eP!OIV_{M8pgACI&4 z4UCm%bojt0#{ybpN#sU`l0GgQmDm13n}*B~!p;-Vv9)fuLyp7Z!wqu7<@eEt(l-AZ z;;m-gfM#fV50gAQsbUL1U|9N1$^D4$kkj5mMr|vG0Nghl z;WZk{+)k?bV`K-W97HazuwO(tgYy^6)^+k>Vv5xu<{6+mG!3 z|L^}b4xCpwMaE7ZW@zCpTBvCGI^A9^{To_Xu7x#P_+2ghkrw_^3+uJ8MGM=t@I5Uo z{fO64q=gf-(4vKXwD7$y4)?Ma9?-(4w6IPKeOh?C7Eaf~aaw56LX#GDf2g;Rhcn;f z;Wr~ZoUVm-E&Q4m4%9-U7ItanUe&_GS{T;C|IxyqY2kOZ@E$E3poKSSp;ZfS)xtWh zo`u?TsTS(g-+z|J)@Wgo7KXKQU)P?m(L$pZex~IsTKKXSzNCeFwNS5T;rl!m{(y(O zw6MRHuERa3rR&cFwft-?yuTOxVGUlw8+dhA+JH%5XaT7lpQQ z<8yQK?0MEayEV@?aiT3x5K?co2#ZRpe3td47HPe|ssu=;SNf}bl`DN^>&q=`OE#3O zon*;cjr3J3%U4!z9<_F5<(&j3RQSFzs%qWJwQK1Ce-$e$eVfPT+QuQiY4bhzz|$&x zbA4Gk<*i-6{w@mXFV$66wQ7Ck>PePW>&weaR{2U+TYT#+sJzmWRW%~3$}$RJY8>2Z zDxiaAXQ5q#doS6OnmpEy-o zxqe*_I-RRll~nkqTCz8fDIbY~OV;}>D=SMZRlb$wtINvow4l7-r`%c(if#m&%djD{YK=J zST>>)EyJ^_hI5eNhW{Ew5U=QU2B7+5l(y0yq)*rkB4Mj_Q3B zaMmxtM{q4)0uENA&~=4+HT2Pd+ShU_Mjw@<_QG!>{2l4~Uw=d_?SimaOVIg(Rk5%O z>G~g)+k@xc?I5_0I5MdmNn3KT7Z2j_zJ?I+9&Sxt`qnGai;~@CoJXFOU^sOZL zRqIz%GW%OsQdPAQs?Aw2-?Pv&f60oOw|QnGr>bOCWeNP9(e!ym?t=Nw`EIRTG@amA z%yrLM;GQ=hd8E(?q>Pj&{^+@UR{;-&uoh}T*VHVbip5t8Wr(d3)(e%wYGIV1r!NrZ3SMCne*HqZU=i*VRtoEc z62u6?B2)l=z2L(?DywUCL70c9QlxJLd?nzQ2?fYqi857qs=_m`!OgTUcm;(7Ep=DP zX0FkA`o_vKmb|)zT3bQ0i>B~6T^6C}D)qZiODXE}qgJ2bVbsy2(i3kPW(bb3N?3yu zYw_PQP+oy}IbzhNb@*>3o_L4!EWc{~x^>XkKyi6{7oyZ!VFNHNL#_`YaZdl^cu2id zv*-CrR<4UR9zd}YZebJ3>VLc(*u^FZR?fYtBvy1d3T=*T=hF)hW~THl8h7QUXGPGa!6B4z3@b zO@Fx@j^KOatNW60;VZzAzWY1U^*^G+^jgn)tyb$;Yp&I19cLYHonW14g_$$fI(F>X z+_AQ?yvyK}(E_a-5+_-V$$4wYFah!cz-gxWyvEy^c+s2O@KYsj#@e{|}$LCG3P8d5O zcY4sv=zUS5{6&1yjQqOVGV*%iz3Sp{qw>-hyfK z3g&vIxf!$|ESTLhWuAMsE6Nb2oL6{eLs9GS1>W1{xqAV`v@zGeRGXD-)bSH0+Vh;# z3S92#T6Kb7`}>Bk++SL$KgB|f03Gxzhs(ZliGP0q8s9X|mc1UUo96KfJX^FRT@O&0 z+@U2RAUn#0=WH!Wha-Fkk*@z45NYqYGQNyAbSRF`f@h1Cq~jxcp6&(Lb_F=1XW5%t zVFdKN3C|WSiSY41eO}FU@aH8wbbN=0|F^v>fokgN)+ZPuf+!%U5yhxjM=)Se98i=& zP{7Enq9Kp~ktrr&R1~dN99pT`s;#Y5)H-2tYOUJ8I8>>%O4X{ZTB$=F|B9`(TC08E zzV`+Kt^MCx@2&U$>n+Y&o9~=`_L=rQ=iHlf_r8=I=5g9%4vXh`j$#NkPRSh3JHL`c z?U!E?%2Z`mqk;Hx+F-(UD>`KY{co(1uLG949XW6gsCem@^wt5axOQ;C;ZXs2;F}+( z$PHlC5viF6w+1l3*AuVDe;?q#WKVvV4_pG3_phG2-f3LmvaiD>r|OCWAC3L~n3cz# zz}@eBQxK4UC-8Nv-u?S7mIe8=@c!swMRbtWyyw@af3q-Xj#JkGH+xkDbvysVZ?#?z zgYGOT8!~Z3pJ4Y&o09vls)9RYS?}4icX{xd&x5;P+gKgkV&;WAZ`V8zo*RD5pdLMN z%r#lTsV7cpV_bD{0ed^VJ7&jw?fafNd3sEjv1=YKnA$I~(d@0-d2n_%BaJ-fl78H{9@e>9r$CS>a=z z4r#Oh*}8CPVf9yiJ~D7E&D!f*s~3-s@H=+-+&<5|h}J{iSfcxFTg3YT zmw%np`D(=LE6(PuD{nu3&&Q$d7Keq6cXV!Z@7xD-#3iVIhmuw#q)w(F|pB+4mQR5RTZcTaoepK?V z3rRVTE=RfPk4-BH@A-+Iu}%>$ zpYZda9Q%dC>9sG}ydL{}#nCbHv7g2I4c$BOz?$D;Q{3C_{pCG*T=73UyktDCiL1T! z&i%H}R>v*bap;#mBWmLAPZ?<39WIVf_hF^o)I;Jw8_gc-KF*Hc->2C3>Y4KRzKXJ= z-&S9U_ZbzE@A$OM#Dl#(?%qiVnE1f(ctcM`{=|xgpp};uqwEhb=B~JOBB>cHzO6K)9LTde{O*yiCipRE;vMD*8_V~sX zpPk~QzADKqYc+N2%y9QWvH#R_7ZW{VtW8r-IDMSIMY4J7?6{llV?wS>{oqZdr_ZbH zRFe-}FPN(jQ5o(|=~%vGma5mTq4#fe*rj@)YL$NF@=eu0Kl&ml?&~gz4()#4i4^NcDr7WGJy8g$sS5ux;?*H*h z(xDXJcc$H0`SelBD}mNGiuUzSJv+9?2d_O;r!MSrZ_>``Z>HXLfB%77n-i(+@@(SH zl!(&KuQ=Y{=B`hg{m^HFk89J@LIR&Bz1#J@v`Jro@^pUc*J(S(RurZlwAFnOv29!J zUVq)Br1R%H-ZbeR4E@snifoJSTwqz+;^)7hi+jY*X* z&1U^z55@gm(`;Xz?<=}{Yg$;{##avZ?3yl*?fr07UR3)2bZ@WOF(v6+B(tA=H|-zk zeKpxrzp(l_-N(;v(5%C~GUm2^?eLV{Q!>6f=KI#Z(q$P(pB(kStvHr3c<k27%zCc6q7K$NJkV z6mMr6@9P~evx7Z1^_U*(Jj!dpviRxg6JLL}@59%oUprs;ox=O@^h>Ww+aG%V>-4Ax zYu`3J_b{A&6!2clPm>G_AFf#VdDcq9R>P_-cfe@yp!FHS(*2jB}z5 z;!obnFxHrkb^oyTJ)=0XVC%K`bH-OT#=Y73zMaXr`qAa-IipM+3r#U6Pv@B4UG>$S zIb*h(lK(j5y`%N_rs1C&XI~!gl4JLQ^2*uru{o)k%j~opi*u@M@*9wnR@?b@2)(ylEQaS&Uc^r zXhFx|(eF>3`CIg<^o2I1GkyCWKDyQR$joC8jeBG5pUiyxpfqKhazN3rm7S{6mn9e3 z`gN<6Jn^*#k}6hIgH@ZFX7p-T6PC_Nwo%LfUQ*&Gj!vB+qq7}4b4@Yuhb^Pk8ktU? zT%Tt6r?|FwA`~<0&X4H9@V_0pTS^YFO#G`j|NKvEHAIhXr?k{zGpc z*XzGY2aAPt@hah*YK8D#A{}Q92AruY%{+1LK&LR~5Qm49Ld8IGq5+ z;y_!Sl)?XmjLOhz^?%9=h%%RtQ>SZ3Wn}zG!kjPDi~U7NR0-%%!=Ili*7LYmz?dvL z!OoIt^Xc3ky$~uWd4YTq<`3R-WG8b6?KsQ)>aXkN_PdMdrQ6o9ppt;@bJI>x6E0@>7{AKrMviXtP-$kJ|ksPDC6~NBVb2Cza4k; z<#{1_y*Q=ooJFkqB#MGw6sY=Ii~Kr^IF+F~%;66Niu;48UdzxRh2NkqBIbXJJ43Y; zX%x3YDjqWCphvuE+muIjnd`P}pX#>^W*OpLK$$A!V{N=Jko*OU{96`rDnxadgJru^ zuVrYEVocUv#C&VeXV8lR$tx}L6D{IYhUzc}%XX<=%g`Xj*kkmy68Ts=FASvbYK#0@ z#GAHFg{dxc-IncB{g%NjL%b05S&lV?HTl9oTYQK`ej4I0>H}3mbyA-xSoVY3X%rmD z=8G{;Iudi&=qRt!5r5t^^D?tI-uuukBD`E?mb+ZeYQQV4FPqO2H^XALK3%}y&?+H= z&U@uBv=PHQ^ESaT8tuRk+)-FQFXErZJCe!=Vu`jB5jXiN!d=I5}A(o|2R6-I&M8 z$s6&aIXU0PJWkFZJl{^xm4SczlaGC*H@eNI-J@v;v|ruB#TR(o8yec9XVP`x%DER7 z7HX29dS-+7m7MMkreycfQCzzYjd+u|b~{?~qIo$Pc-(cQveCSp9K4V=XeVFj-!=4w z`p2c+^QnKD>-Y{7@%TC6O+5b_*zX#61Bn+8p2gfz5RdGG$a_#IJBWB>Qd{Q?9^WLl z=W_Fsn{ozLjI|J=YQa2{j7CnpSj=Wp9eSZashIgA!!tESr!l&7XVJJ{;Mod16Aqyf z#1?6Hq;VhN);Z<7PvXbUD#a`jd7cKNA=zE-g(yn|uUJ&itY$@_#OWxqups1~cwbj_Lwu+Xlt+$NSZ9qB>lp3GoD~jKMo(qxg!*}D%pV`V{A)l8 zn}oEZaAo@esoe}A{fdx2D5Nh6Y3IRwc~2n8?-kOgg>*Nef5XiEYiq?M1}knH9Y4Z8 zGL$dpKa8)(1f+T#oyF+CEy;5I_lGQnM9fCYzs=1`oXwj1P4({N>rI1f;t*bLEb6DA z5!yK*q|XUyk+l`~$yRA+39~n}s%u$mUDHBul}Oi1j&j|)N?6w;j?5|A0dj4ag9px# zL9+A6Lw=())n$^f#2$EG04fn=EYl)bd`rBo($0*PgUqs)X{o)4iIe#GQEDDP zWNG};3HHq2q>%b*21?}$Z)sOif2nPqO|7IxTxEqhwf=2*NTE#R=e)ebCei|9oq<%o zzkmlYHz?Gizr@FX%;dsJAeIk12PD34Pu@m6w-=wD2gGz{vc7!!SwH@qyhDFJodaxv z{G~!#+K=XCJIqTbTvtbKUQ!=x(MJrCYlB(zsTj(ocAt=v5%Rk8{dpBgd`HsFTwXUe zdwHIDEQEU86G^TJNMSyZ#T3%M3Vu*709*Uq+C48 zQK%C7=LLOI7$@jeWNXcA4@qjp`W8wn)WKc4=!CHfcb4V#29({lxdOF$}nOF+_R zaYvqa8c5+eko4JJ%JaQ|=qY;t=LR;VRYs)e%ZKCfQ^qE2}c6;h;)BMNgd{;i-4(oga2>BpxO5_Tfy6^Q zl;4nsW=u`WLB_Hksb?$JMf16+i=tZ8MRZ8irna@-PRaL;;l3{IEXMt$9kc&QqUZXH z@}j|FHdw*WU6GBL*+gP?B?@~>v@P=wM6;k;u21MgQy#YmS+Ocu*Nw@*e7nl`-7+m| zVZ~6VvYVF;^Li*@((BgD*@V*%MGID!$(Tnr^l*vFN$_&t8V!o^imGv*bVw`KTj3_^ zAnGWxspHlFYUKB*_ydgXgzo7Y`eXeUkKyB8Loh&ug=2;5%he%69i9GEM=|O+F4Un% z9Ta8)X?~UfXw%!uG)P=vlo9~|@G4^R(0KOh8Ry+;<^`QLkz(a=E z#HYzGqL_GSp7JfzmSv=_64n~eHLaJ~=vyXAl+=zt%1H6;F1lAzT84D}b6GV1T*kLA zVO7f*`vFuZwACohJqt*faydT93o^@CrX4$qSw~?%rRS=|Dqc@@f?j_Yu<8|_{|Au5 zOAC1Y>VTwIQ3o;WkOo~vTFHfH0=>D9m5cG8K|yP-kUpS1g@jr1__4LZGbf%qBklCk zU^}MJ^lelH2g=J5PbAcb(C2)IZ{zY8RNJ4&&4 zX>hMm*wej-d#1cl#phL`EqgyisPer`*+xoutxY(9Sbfy`^6QJR}WSTA{S zn+BO>EYptNZCQ8R)7|hKw=)f33JZ zVl+5y~X2#DB6}g|e8tgu;4JwxYeIJ7Z?KxVJC_&``(`il`0DS&=>6 zJ8kiNFHwr5woGbjg}GqEq}UsznCDV&ms+k5PLORSVy%*ZbU!ul_fx)nD`xMF@-EiQ zMX`^$i1soG)lGev3v`k&CzB0x!tX#QZ#yOR+Z<%;`Piy!W=;cIAzBIkg(i6p;M18F z1)7(H9YMXzDb_fc&)zKMZvB;<&=1-5#^ov10^|?=U-iW-O=nvaEZZruXot=X%wfcB z#42(BwcxQk_)P_#{s*%Z?u&OZt{oWH%?948dyLh9SA461=X4)3yPzivo;P^K;FVgG zjRenkC+_DKJOg-o@NQY~mVsAFau)UNCOOo%*Fx?bc!`jEQE2w7;x*IkSHyFbFFb$U?qjE|H<;Srl#2F8BYazXw(i3vDhJsjiMvj(5*k~PM_6QQZ57urW1p`?2vb8GQl&>N;AXd!B zVU}+)WEbEwXbpJ~P#JZm95$zsOg)>;=K0BdPgQuSYGm_y9$uHG<9h*IJ2_cgYP_{7 zAWOry8pg-#TU9pX)mI?(Cyt5_@t?$U8glje zzsL`diVaYDDdhZ2^M~!VAvw*!*a()X&4lSSV}qDVpJUJ_lkZ#)rouJUs7zV|=K`X| zQGrSoke?q+<_r83G7Q9%HkD4!)Z@Q#aWOrvl?_R%$j(}qqDxk#aq|r=$-&P}Hkecv zuiVM~0u4sN(+#h@gYYcZO=!9PJ-8}4n`-U;C%*YI;bXn%7^j(_hL`8D0g*8g(V^i% z^<&0wY?YeY*JUTEQgX7A;X9I&l96LfW2}&+V2&E`w8D*BmyK34GqbZ)xhZ-$ubEQt zZoFxZQOLo#=t>V#;5jPApv9`Ig=b-^H-j%rgZ^f+WUUTs{1r~~q%p@o*O(_%$)vDX zro^m8&ykXJuk#<7tR->y_3ar2a|-Glg<#aBOfxT%~0( zjGwERKU^f5?`ujX=g}laPxUHX1w$%EX5ElNzuKe6d|4O7_|kq%WzeSTj5Km#DUiWK z2B`tdgTz%dU6a&U)-><ZNd0K#dQL+h5EocG6>d&Jawokyn8BTtv*0j>v@kuKXK!^^|VgI|12@@ei^ zW;ZRLrd8|zE}yRX-{l)}@GY9gO*H8NwgUJF{aqcrE*nX-6$NTDv?gsp<0Z`gA>50C zaxs~3*C=ebr}5hccsqzkw~$d94ZKEiSNK94Y03yt>rI%iFs0$#IZhKV3@*Ak`d~rR zL0KjP_JVIHCst=L<)|}avY=?(J$75iWbs>#rhXT|JrGj|J|EUmTGI=&UH^PvW6P|g z%{!lPtHV90MW|6oWE+BU>qlReoYO1(zr@_FUa2*3zOV2n3CM=t(YVZ_cI;8u&T-Sk z+gxZMssJ-PGa46Xl#y=N6l19^8n(x%FwFfB6k$bZJ5ZaHlbWhEnA?2OFNgnIKHgvZ z)2}!4@6v}tBoV*KD45fHs`+oT2AVa{tbt|?G;5$)1I-#})n6PUNy+y2|4Ti<*Hp#5wlY@&rTvw@>fi1C z3puVn@?GU#-|)Vx7DddLq#6I68gPIODv0b6@$Fb<5aPwaH-&f^@Td^S_h#96M_#@P z*wcxzw69SXc%vQcq!9Oa#`{1Q_=_Q~1Wp4{{d(YMAo5A80rqQ;_s)pRfs;GHwi0pj zC%7SnZ8dEDE$#ft{y*6j_S)bR7K17gC%gc9{0-jQ0;4(u!A}G(1?@f$doG~amxl01 zP$~F?{oo(59&z%M2zA4^%~6k~Plct=1^HgY$RH0H!lG`l2}8UXxTibt0`KRM&;xaV zZ|UDdem`458ni`t1(c6C`PbONZ>R=wOP?X~C7R(0n>FwW-vUJ=UIu&&BEKMfppVS~ zCBSBx{89SL@#Yxq!WES51CdM>@EnNrUkCiw3o_u7e?+b~@}Vp8EsIq^9{MLgsy05* z?K$)ZIKdb8al{8s83K8V11}9l9grbEt-@g_i+C}x(@6C3B5UNsVCnNfz7J)fc*qbQ z0A(OfcosAhal)IRQpD*?T8sVB7sN|}y+p)KD0CL&%6Of~WAo$RHPb1+uu-_l-~?1&9{sQ)UD zC5ZP%+|vG;?4t28OO}SRgr1<8h|7T$AiAbxHyktzagS3k`0Ifmf=Gt`;nqVCmHi#) zvzq7o0_T8;KMxrG7V;sl1l|UnMf@Jn;cZ@qaF`Gu4qPn6mjKH_)E4>F^jL#6dJSs> z_&P|2IKE-RJ_S)*_|7`}?j3&YwLqJ9`Lcw=K_o+HzZNnm>j0bsk|REkunhT#X8;#~ zxORcJ-@{x5{~pkP9nV(+ON2P#X%OlBEYPi-kCVN4Du~)8TkT^){1&jwdY+GOoUmLF z&F6gJDp3429`W51E`ApH)<*0D;8(p5ze|uFak9xLd;1etd5lE-A>!nJ8M6gz^a5)R z{{b4XMIY=z4xk{A0n`pe{3Os|5N>VwjxvvN0!{(iftthr3k?+izZgaHApVCM5W(`4 ztWQ~S*eJs?(naHNk zll%3Gi4OMg?Ioj6IBV1yu*>x8RiHKY8acw=b~t@eIx{JwK!yskjDEdx3|T{s$!Xe5 zwb3I}mu$#3W~Z1uU>aBcyTMk2Q=!_@B#IML-FAQ%z8uO&zIxR zoJu?ofLmI=s(e#)xC+4|m_<(qG9uG`G2@C-t7+g5FpRrIcq zSNK-=S0q-XRp={9DoQI>RrqdKZjaxdzrA>S$@bFibn@1kS}OxNh?p~=ZoR{X3mYD9 QkZlaX6GL + +// clang-format off + +#if defined(DISCORD_DYNAMIC_LIB) +# if defined(_WIN32) +# if defined(DISCORD_BUILDING_SDK) +# define DISCORD_EXPORT __declspec(dllexport) +# else +# define DISCORD_EXPORT __declspec(dllimport) +# endif +# else +# define DISCORD_EXPORT __attribute__((visibility("default"))) +# endif +#else +# define DISCORD_EXPORT +#endif + +// clang-format on + +#ifdef __cplusplus +extern "C" { +#endif + +typedef struct DiscordRichPresence { + const char* state; /* max 128 bytes */ + const char* details; /* max 128 bytes */ + int64_t startTimestamp; + int64_t endTimestamp; + const char* largeImageKey; /* max 32 bytes */ + const char* largeImageText; /* max 128 bytes */ + const char* smallImageKey; /* max 32 bytes */ + const char* smallImageText; /* max 128 bytes */ + const char* partyId; /* max 128 bytes */ + int partySize; + int partyMax; + const char* matchSecret; /* max 128 bytes */ + const char* joinSecret; /* max 128 bytes */ + const char* spectateSecret; /* max 128 bytes */ + int8_t instance; +} DiscordRichPresence; + +typedef struct DiscordUser { + const char* userId; + const char* username; + const char* discriminator; + const char* avatar; +} DiscordUser; + +typedef struct DiscordEventHandlers { + void (*ready)(const DiscordUser* request); + void (*disconnected)(int errorCode, const char* message); + void (*errored)(int errorCode, const char* message); + void (*joinGame)(const char* joinSecret); + void (*spectateGame)(const char* spectateSecret); + void (*joinRequest)(const DiscordUser* request); +} DiscordEventHandlers; + +#define DISCORD_REPLY_NO 0 +#define DISCORD_REPLY_YES 1 +#define DISCORD_REPLY_IGNORE 2 + +DISCORD_EXPORT void Discord_Initialize(const char* applicationId, + DiscordEventHandlers* handlers, + int autoRegister, + const char* optionalSteamId); +DISCORD_EXPORT void Discord_Shutdown(void); + +/* checks for incoming messages, dispatches callbacks */ +DISCORD_EXPORT void Discord_RunCallbacks(void); + +/* If you disable the lib starting its own io thread, you'll need to call this from your own */ +#ifdef DISCORD_DISABLE_IO_THREAD +DISCORD_EXPORT void Discord_UpdateConnection(void); +#endif + +DISCORD_EXPORT void Discord_UpdatePresence(const DiscordRichPresence* presence); +DISCORD_EXPORT void Discord_ClearPresence(void); + +DISCORD_EXPORT void Discord_Respond(const char* userid, /* DISCORD_REPLY_ */ int reply); + +DISCORD_EXPORT void Discord_UpdateHandlers(DiscordEventHandlers* handlers); + +#ifdef __cplusplus +} /* extern "C" */ +#endif diff --git a/discord-rpc/win64-static/lib/discord-rpc.lib b/discord-rpc/win64-static/lib/discord-rpc.lib new file mode 100644 index 0000000000000000000000000000000000000000..97fadadcc81e26df7cde6dd5969c17983162533a GIT binary patch literal 264048 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