Rim/t7x
Rim/t7x
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 1 Wiki Activity

Fix some formatting

Browse Source
This commit is contained in:
momo5502 2022-05-23 17:57:45 +02:00
parent feb1282e03
commit c9793ce592
19 changed files with 797 additions and 843 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
src/client/component/console.cpp
View File

@ -7,13 +7,13 @@
namespace console namespace console
{ {
namespace namespace
{ {
void create_game_console() void create_game_console()
{ {
reinterpret_cast<void(*)()>(utils::nt::library{}.get_ptr() + 0x2333F80)(); reinterpret_cast<void(*)()>(utils::nt::library{}.get_ptr() + 0x2333F80)();
} }
} }
class component final : public component_interface class component final : public component_interface
{ {
@ -24,21 +24,21 @@ namespace console
this->console_runner_ = utils::thread::create_named_thread("Console IO", [this] this->console_runner_ = utils::thread::create_named_thread("Console IO", [this]
{ {
create_game_console(); create_game_console();
MSG msg{}; MSG msg{};
while (!this->terminate_runner_) while (!this->terminate_runner_)
{ {
if (PeekMessageA(&msg, nullptr, NULL, NULL, PM_REMOVE)) if (PeekMessageA(&msg, nullptr, NULL, NULL, PM_REMOVE))
{ {
TranslateMessage(&msg); TranslateMessage(&msg);
DispatchMessage(&msg); DispatchMessage(&msg);
} }
else else
{ {
std::this_thread::sleep_for(1ms); std::this_thread::sleep_for(1ms);
} }
} }
}); });
} }

9
src/client/component/scheduler.cpp
View File

@ -74,7 +74,8 @@ namespace scheduler
{ {
new_callbacks_.access([&](task_list& new_tasks) new_callbacks_.access([&](task_list& new_tasks)
{ {
tasks.insert(tasks.end(), std::move_iterator<task_list::iterator>(new_tasks.begin()), std::move_iterator<task_list::iterator>(new_tasks.end())); tasks.insert(tasks.end(), std::move_iterator<task_list::iterator>(new_tasks.begin()),
std::move_iterator<task_list::iterator>(new_tasks.end()));
new_tasks = {}; new_tasks = {};
}); });
}); });
@ -114,7 +115,7 @@ namespace scheduler
} }
void schedule(const std::function<bool()>& callback, const pipeline type, void schedule(const std::function<bool()>& callback, const pipeline type,
const std::chrono::milliseconds delay) const std::chrono::milliseconds delay)
{ {
assert(type >= 0 && type < pipeline::count); assert(type >= 0 && type < pipeline::count);
@ -127,7 +128,7 @@ namespace scheduler
} }
void loop(const std::function<void()>& callback, const pipeline type, void loop(const std::function<void()>& callback, const pipeline type,
const std::chrono::milliseconds delay) const std::chrono::milliseconds delay)
{ {
schedule([callback]() schedule([callback]()
{ {
@ -137,7 +138,7 @@ namespace scheduler
} }
void once(const std::function<void()>& callback, const pipeline type, void once(const std::function<void()>& callback, const pipeline type,
const std::chrono::milliseconds delay) const std::chrono::milliseconds delay)
{ {
schedule([callback]() schedule([callback]()
{ {

8
src/client/component/scheduler.hpp
View File

@ -23,11 +23,11 @@ namespace scheduler
static const bool cond_end = true; static const bool cond_end = true;
void schedule(const std::function<bool()>& callback, pipeline type = pipeline::async, void schedule(const std::function<bool()>& callback, pipeline type = pipeline::async,
std::chrono::milliseconds delay = 0ms); std::chrono::milliseconds delay = 0ms);
void loop(const std::function<void()>& callback, pipeline type = pipeline::async, void loop(const std::function<void()>& callback, pipeline type = pipeline::async,
std::chrono::milliseconds delay = 0ms); std::chrono::milliseconds delay = 0ms);
void once(const std::function<void()>& callback, pipeline type = pipeline::async, void once(const std::function<void()>& callback, pipeline type = pipeline::async,
std::chrono::milliseconds delay = 0ms); std::chrono::milliseconds delay = 0ms);
void on_game_initialized(const std::function<void()>& callback, pipeline type = pipeline::async, void on_game_initialized(const std::function<void()>& callback, pipeline type = pipeline::async,
std::chrono::milliseconds delay = 0ms); std::chrono::milliseconds delay = 0ms);
} }

22
src/client/component/splash.cpp
View File

@ -6,14 +6,14 @@
namespace splash namespace splash
{ {
namespace namespace
{ {
HANDLE load_splash_image() HANDLE load_splash_image()
{ {
const auto self = utils::nt::library::get_by_address(load_splash_image); const auto self = utils::nt::library::get_by_address(load_splash_image);
return LoadImageA(self, MAKEINTRESOURCE(IMAGE_SPLASH), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR); return LoadImageA(self, MAKEINTRESOURCE(IMAGE_SPLASH), IMAGE_BITMAP, 0, 0, LR_DEFAULTCOLOR);
} }
} }
class component final : public component_interface class component final : public component_interface
{ {
@ -46,9 +46,9 @@ namespace
this->window_ = nullptr; this->window_ = nullptr;
} }
void post_unpack() override void post_unpack() override
{ {
this->destroy(); this->destroy();
} }
private: private:
@ -69,7 +69,7 @@ namespace
{ {
WNDCLASSA wnd_class; WNDCLASSA wnd_class;
const utils::nt::library host{}; const utils::nt::library host{};
wnd_class.style = CS_DROPSHADOW; wnd_class.style = CS_DROPSHADOW;
wnd_class.cbClsExtra = 0; wnd_class.cbClsExtra = 0;

214
src/client/main.cpp
View File

@ -8,124 +8,138 @@
namespace namespace
{ {
DECLSPEC_NORETURN void WINAPI exit_hook(const int code) DECLSPEC_NORETURN void WINAPI exit_hook(const int code)
{
component_loader::pre_destroy();
exit(code);
}
VOID WINAPI initialize_critical_section(const LPCRITICAL_SECTION lpCriticalSection)
{
component_loader::post_unpack();
InitializeCriticalSection(lpCriticalSection);
}
void patch_imports()
{
const utils::nt::library game{};
const auto self = utils::nt::library::get_by_address(patch_imports);
auto patch_steam_import = [&](const std::string& func) {
const auto game_entry = game.get_iat_entry("steam_api64.dll", func);
if (!game_entry) {
throw std::runtime_error("Import '" + func + "' not found!");
}
const auto self_proc = self.get_proc<void*>(func);
if (!self_proc) {
throw std::runtime_error(func + " export not found");
}
utils::hook::set(game_entry, self_proc);
};
patch_steam_import("SteamAPI_RegisterCallback");
patch_steam_import("SteamAPI_RegisterCallResult");
patch_steam_import("SteamGameServer_Shutdown");
patch_steam_import("SteamGameServer_RunCallbacks");
patch_steam_import("SteamGameServer_GetHSteamPipe");
patch_steam_import("SteamGameServer_GetHSteamUser");
patch_steam_import("SteamInternal_GameServer_Init");
patch_steam_import("SteamAPI_UnregisterCallResult");
patch_steam_import("SteamAPI_UnregisterCallback");
patch_steam_import("SteamAPI_RunCallbacks");
//patch_steam_import("SteamAPI_Shutdown");
patch_steam_import("SteamInternal_CreateInterface");
patch_steam_import("SteamAPI_GetHSteamUser");
patch_steam_import("SteamAPI_GetHSteamPipe");
patch_steam_import("SteamAPI_Init");
patch_steam_import("SteamAPI_RestartAppIfNecessary");
utils::hook::set(game.get_iat_entry("kernel32.dll", "InitializeCriticalSection"), initialize_critical_section);
utils::hook::set(game.get_iat_entry("kernel32.dll", "ExitProcess"), exit_hook);
}
bool run()
{
srand(uint32_t(time(nullptr)) ^ (~GetTickCount()));
{ {
auto premature_shutdown = true; component_loader::pre_destroy();
const auto _ = utils::finally([&premature_shutdown]() exit(code);
{ }
if (premature_shutdown)
{
component_loader::pre_destroy();
}
});
try VOID WINAPI initialize_critical_section(const LPCRITICAL_SECTION critical_section)
{ {
patch_imports(); component_loader::post_unpack();
InitializeCriticalSection(critical_section);
}
if (!component_loader::post_load()) void patch_imports()
{
const utils::nt::library game{};
const auto self = utils::nt::library::get_by_address(patch_imports);
auto patch_steam_import = [&](const std::string& func)
{
const auto game_entry = game.get_iat_entry("steam_api64.dll", func);
if (!game_entry)
{ {
return false; throw std::runtime_error("Import '" + func + "' not found!");
} }
premature_shutdown = false; const auto self_proc = self.get_proc<void*>(func);
} if (!self_proc)
catch (std::exception& e) {
throw std::runtime_error(func + " export not found");
}
utils::hook::set(game_entry, self_proc);
};
patch_steam_import("SteamAPI_RegisterCallback");
patch_steam_import("SteamAPI_RegisterCallResult");
patch_steam_import("SteamGameServer_Shutdown");
patch_steam_import("SteamGameServer_RunCallbacks");
patch_steam_import("SteamGameServer_GetHSteamPipe");
patch_steam_import("SteamGameServer_GetHSteamUser");
patch_steam_import("SteamInternal_GameServer_Init");
patch_steam_import("SteamAPI_UnregisterCallResult");
patch_steam_import("SteamAPI_UnregisterCallback");
patch_steam_import("SteamAPI_RunCallbacks");
//patch_steam_import("SteamAPI_Shutdown");
patch_steam_import("SteamInternal_CreateInterface");
patch_steam_import("SteamAPI_GetHSteamUser");
patch_steam_import("SteamAPI_GetHSteamPipe");
patch_steam_import("SteamAPI_Init");
patch_steam_import("SteamAPI_RestartAppIfNecessary");
utils::hook::set(game.get_iat_entry("kernel32.dll", "InitializeCriticalSection"), initialize_critical_section);
utils::hook::set(game.get_iat_entry("kernel32.dll", "ExitProcess"), exit_hook);
}
void enable_dpi_awareness()
{
const utils::nt::library user32{"user32.dll"};
const auto set_dpi = user32
? user32.get_proc<BOOL(WINAPI*)(DPI_AWARENESS_CONTEXT)>(
"SetProcessDpiAwarenessContext")
: nullptr;
if (set_dpi)
{ {
MessageBoxA(nullptr, e.what(), "ERROR", MB_ICONERROR); set_dpi(DPI_AWARENESS_CONTEXT_PER_MONITOR_AWARE_V2);
return false;
} }
} }
return true; bool run()
} {
srand(uint32_t(time(nullptr)) ^ (~GetTickCount()));
{
auto premature_shutdown = true;
const auto _ = utils::finally([&premature_shutdown]()
{
if (premature_shutdown)
{
component_loader::pre_destroy();
}
});
try
{
enable_dpi_awareness();
patch_imports();
if (!component_loader::post_load())
{
return false;
}
premature_shutdown = false;
}
catch (std::exception& e)
{
MessageBoxA(nullptr, e.what(), "ERROR", MB_ICONERROR);
return false;
}
}
return true;
}
} }
BOOL WINAPI DllMain(HINSTANCE, const DWORD reason, LPVOID) BOOL WINAPI DllMain(HINSTANCE, const DWORD reason, LPVOID)
{ {
if (reason == DLL_PROCESS_ATTACH) { if (reason == DLL_PROCESS_ATTACH)
if(!run()) { {
return FALSE; if (!run())
} {
} return FALSE;
return TRUE; }
}
return TRUE;
} }
extern "C" __declspec(dllexport) extern "C" __declspec(dllexport)
HRESULT D3D11CreateDevice( HRESULT D3D11CreateDevice(void* adapter, const uint64_t driver_type,
void* pAdapter, const HMODULE software, const UINT flags,
uint64_t DriverType, const void* p_feature_levels, const UINT feature_levels,
HMODULE Software, const UINT sdk_version, void** device, void* feature_level,
UINT Flags, void** immediate_context)
const void* pFeatureLevels,
UINT FeatureLevels,
UINT SDKVersion,
void** ppDevice,
void* pFeatureLevel,
void** ppImmediateContext
)
{ {
static auto func = [] { static auto func = []
char dir[MAX_PATH]{ 0 }; {
GetSystemDirectoryA(dir, sizeof(dir)); char dir[MAX_PATH]{0};
GetSystemDirectoryA(dir, sizeof(dir));
const auto d3d11 = utils::nt::library::load(dir + "/d3d11.dll"s); const auto d3d11 = utils::nt::library::load(dir + "/d3d11.dll"s);
return d3d11.get_proc<decltype(&D3D11CreateDevice)>("D3D11CreateDevice"); return d3d11.get_proc<decltype(&D3D11CreateDevice)>("D3D11CreateDevice");
}(); }();
return func(pAdapter, DriverType, Software, Flags, pFeatureLevels, FeatureLevels, SDKVersion, ppDevice, pFeatureLevel, ppImmediateContext); return func(adapter, driver_type, software, flags, p_feature_levels, feature_levels, sdk_version, device,
feature_level, immediate_context);
} }

609
src/client/steam/interfaces/client.cpp
View File

@ -1,356 +1,277 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../steam.hpp" #include "../steam.hpp"
namespace steam { namespace steam
namespace {
void* get_dummy()
{ {
static class blub { namespace
public: {
virtual uint64_t m0() { return 0; } void* get_dummy()
virtual uint64_t m1() { return 0; } {
virtual uint64_t m2() { return 0; } class blub
virtual uint64_t m3() { return 0; } {
virtual uint64_t m4() { return 0; } public:
virtual uint64_t m5() { return 0; } virtual uint64_t m0() { return 0; }
virtual uint64_t m6() { return 0; } virtual uint64_t m1() { return 0; }
virtual uint64_t m7() { return 0; } virtual uint64_t m2() { return 0; }
virtual uint64_t m8() { return 0; } virtual uint64_t m3() { return 0; }
virtual uint64_t m9() { return 0; } virtual uint64_t m4() { return 0; }
virtual uint64_t m5() { return 0; }
virtual uint64_t m6() { return 0; }
virtual uint64_t m7() { return 0; }
virtual uint64_t m8() { return 0; }
virtual uint64_t m9() { return 0; }
virtual uint64_t m10() { return 0; } virtual uint64_t m10() { return 0; }
virtual uint64_t m11() { return 0; } virtual uint64_t m11() { return 0; }
virtual uint64_t m12() { return 0; } virtual uint64_t m12() { return 0; }
virtual uint64_t m13() { return 0; } virtual uint64_t m13() { return 0; }
virtual uint64_t m14() { return 0; } virtual uint64_t m14() { return 0; }
virtual uint64_t m15() { return 0; } virtual uint64_t m15() { return 0; }
virtual uint64_t m16() { return 0; } virtual uint64_t m16() { return 0; }
virtual uint64_t m17() { return 0; } virtual uint64_t m17() { return 0; }
virtual uint64_t m18() { return 0; } virtual uint64_t m18() { return 0; }
virtual uint64_t m19() { return 0; } virtual uint64_t m19() { return 0; }
virtual uint64_t m20() { return 0; } virtual uint64_t m20() { return 0; }
virtual uint64_t m21() { return 0; } virtual uint64_t m21() { return 0; }
virtual uint64_t m22() { return 0; } virtual uint64_t m22() { return 0; }
virtual uint64_t m23() { return 0; } virtual uint64_t m23() { return 0; }
virtual uint64_t m24() { return 0; } virtual uint64_t m24() { return 0; }
virtual uint64_t m25() { return 0; } virtual uint64_t m25() { return 0; }
virtual uint64_t m26() { return 0; } virtual uint64_t m26() { return 0; }
virtual uint64_t m27() { return 0; } virtual uint64_t m27() { return 0; }
virtual uint64_t m28() { return 0; } virtual uint64_t m28() { return 0; }
virtual uint64_t m29() { return 0; } virtual uint64_t m29() { return 0; }
virtual uint64_t m30() { return 0; } virtual uint64_t m30() { return 0; }
virtual uint64_t m31() { return 0; } virtual uint64_t m31() { return 0; }
virtual uint64_t m32() { return 0; } virtual uint64_t m32() { return 0; }
virtual uint64_t m33() { return 0; } virtual uint64_t m33() { return 0; }
virtual uint64_t m34() { return 0; } virtual uint64_t m34() { return 0; }
virtual uint64_t m35() { return 0; } virtual uint64_t m35() { return 0; }
virtual uint64_t m36() { return 0; } virtual uint64_t m36() { return 0; }
virtual uint64_t m37() { return 0; } virtual uint64_t m37() { return 0; }
virtual uint64_t m38() { return 0; } virtual uint64_t m38() { return 0; }
virtual uint64_t m39() { return 0; } virtual uint64_t m39() { return 0; }
virtual uint64_t m40() { return 0; } virtual uint64_t m40() { return 0; }
virtual uint64_t m41() { return 0; } virtual uint64_t m41() { return 0; }
virtual uint64_t m42() { return 0; } virtual uint64_t m42() { return 0; }
virtual uint64_t m43() { return 0; } virtual uint64_t m43() { return 0; }
virtual uint64_t m44() { return 0; } virtual uint64_t m44() { return 0; }
virtual uint64_t m45() { return 0; } virtual uint64_t m45() { return 0; }
virtual uint64_t m46() { return 0; } virtual uint64_t m46() { return 0; }
virtual uint64_t m47() { return 0; } virtual uint64_t m47() { return 0; }
virtual uint64_t m48() { return 0; } virtual uint64_t m48() { return 0; }
virtual uint64_t m49() { return 0; } virtual uint64_t m49() { return 0; }
virtual uint64_t m50() { return 0; } virtual uint64_t m50() { return 0; }
virtual uint64_t m51() { return 0; } virtual uint64_t m51() { return 0; }
virtual uint64_t m52() { return 0; } virtual uint64_t m52() { return 0; }
virtual uint64_t m53() { return 0; } virtual uint64_t m53() { return 0; }
virtual uint64_t m54() { return 0; } virtual uint64_t m54() { return 0; }
virtual uint64_t m55() { return 0; } virtual uint64_t m55() { return 0; }
virtual uint64_t m56() { return 0; } virtual uint64_t m56() { return 0; }
virtual uint64_t m57() { return 0; } virtual uint64_t m57() { return 0; }
virtual uint64_t m58() { return 0; } virtual uint64_t m58() { return 0; }
virtual uint64_t m59() { return 0; } virtual uint64_t m59() { return 0; }
virtual uint64_t m60() { return 0; } virtual uint64_t m60() { return 0; }
virtual uint64_t m61() { return 0; } virtual uint64_t m61() { return 0; }
virtual uint64_t m62() { return 0; } virtual uint64_t m62() { return 0; }
virtual uint64_t m63() { return 0; } virtual uint64_t m63() { return 0; }
virtual uint64_t m64() { return 0; } virtual uint64_t m64() { return 0; }
virtual uint64_t m65() { return 0; } virtual uint64_t m65() { return 0; }
virtual uint64_t m66() { return 0; } virtual uint64_t m66() { return 0; }
virtual uint64_t m67() { return 0; } virtual uint64_t m67() { return 0; }
virtual uint64_t m68() { return 0; } virtual uint64_t m68() { return 0; }
virtual uint64_t m69() { return 0; } virtual uint64_t m69() { return 0; }
} x;
return &x;
}
}
} x; HSteamPipe client::CreateSteamPipe()
return &x; {
} return 1;
}
}
bool client::BReleaseSteamPipe(HSteamPipe hSteamPipe)
HSteamPipe client::CreateSteamPipe() {
{ return true;
OutputDebugStringA(__FUNCTION__); }
return 1;
} HSteamUser client::ConnectToGlobalUser(HSteamPipe hSteamPipe)
{
bool client::BReleaseSteamPipe(HSteamPipe hSteamPipe) return 1;
{ }
OutputDebugStringA(__FUNCTION__);
return true; HSteamUser client::CreateLocalUser(HSteamPipe* phSteamPipe, uint32_t eAccountType)
} {
return 1;
HSteamUser client::ConnectToGlobalUser(HSteamPipe hSteamPipe) }
{
OutputDebugStringA(__FUNCTION__); void client::ReleaseUser(HSteamPipe hSteamPipe, HSteamUser hUser)
return 1; {
} }
HSteamUser client::CreateLocalUser(HSteamPipe* phSteamPipe, uint32_t eAccountType) void* client::GetISteamUser(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{ {
OutputDebugStringA(__FUNCTION__); return SteamUser();
return 1; }
}
void* client::GetISteamGameServer(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
void client::ReleaseUser(HSteamPipe hSteamPipe, HSteamUser hUser) {
{ return SteamGameServer();
OutputDebugStringA(__FUNCTION__); }
}
void client::SetLocalIPBinding(uint32_t unIP, uint16_t usPort)
void* client::GetISteamUser(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ }
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion); void* client::GetISteamFriends(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
return SteamUser(); return SteamFriends();
} }
void* client::GetISteamGameServer(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) void* client::GetISteamUtils(HSteamPipe hSteamPipe, const char* pchVersion)
{ {
OutputDebugStringA(__FUNCTION__); return SteamUtils();
OutputDebugStringA(pchVersion); }
return SteamGameServer();
} void* client::GetISteamMatchmaking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
void client::SetLocalIPBinding(uint32_t unIP, uint16_t usPort) return SteamMatchmaking();
{ }
OutputDebugStringA(__FUNCTION__);
} void* client::GetISteamMatchmakingServers(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
void* client::GetISteamFriends(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) static matchmaking_servers u;
{ return &u;
OutputDebugStringA(__FUNCTION__); }
OutputDebugStringA(pchVersion);
void* client::GetISteamGenericInterface(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
return SteamFriends(); {
} return nullptr;
}
void* client::GetISteamUtils(HSteamPipe hSteamPipe, const char* pchVersion)
{ void* client::GetISteamUserStats(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
OutputDebugStringA(__FUNCTION__); {
OutputDebugStringA(pchVersion); return SteamUserStats();
return SteamUtils(); }
}
void* client::GetISteamGameServerStats(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
void* client::GetISteamMatchmaking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ static game_server_stats u;
OutputDebugStringA(__FUNCTION__); return &u;
OutputDebugStringA(pchVersion); }
return SteamMatchmaking();
} void* client::GetISteamApps(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
void* client::GetISteamMatchmakingServers(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) return SteamApps();
{ }
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion); void* client::GetISteamNetworking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
static matchmaking_servers u; return SteamNetworking();
return &u; }
}
void* client::GetISteamRemoteStorage(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
void* client::GetISteamGenericInterface(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ return SteamRemoteStorage();
OutputDebugStringA(__FUNCTION__); }
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0); void* client::GetISteamScreenshots(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
return nullptr; {
} static screenshots s;
return &s;
void* client::GetISteamUserStats(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) }
{
OutputDebugStringA(__FUNCTION__); void client::RunFrame()
OutputDebugStringA(pchVersion); {
return SteamUserStats(); }
}
uint32_t client::GetIPCCallCount()
void* client::GetISteamGameServerStats(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ return 0;
OutputDebugStringA(__FUNCTION__); }
OutputDebugStringA(pchVersion);
void client::SetWarningMessageHook(void* pFunction)
static game_server_stats u; {
return &u; }
}
bool client::BShutdownIfAllPipesClosed()
void* client::GetISteamApps(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ return true;
OutputDebugStringA(__FUNCTION__); }
OutputDebugStringA(pchVersion);
return SteamApps(); void* client::GetISteamHTTP(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
} {
static http h;
void* client::GetISteamNetworking(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) return &h;
{ }
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion); void* client::GetISteamUnifiedMessages(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
return SteamNetworking(); {
} static unified_messages u;
return &u;
void* client::GetISteamRemoteStorage(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion) }
{
OutputDebugStringA(__FUNCTION__); void* client::GetISteamController(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
OutputDebugStringA(pchVersion); {
return SteamRemoteStorage(); static controller c;
} return &c;
}
void* client::GetISteamScreenshots(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{ void* client::GetISteamUGC(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
OutputDebugStringA(__FUNCTION__); {
OutputDebugStringA(pchVersion); return get_dummy();
}
static screenshots s;
return &s; void* client::GetISteamAppList(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
} {
return get_dummy();
void client::RunFrame() }
{
OutputDebugStringA(__FUNCTION__); void* client::GetISteamMusic(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
} {
return get_dummy();
uint32_t client::GetIPCCallCount() }
{
OutputDebugStringA(__FUNCTION__); void* client::GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
return 0; {
} return get_dummy();
}
void client::SetWarningMessageHook(void* pFunction)
{ void* client::GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
OutputDebugStringA(__FUNCTION__); {
} return get_dummy();
}
bool client::BShutdownIfAllPipesClosed()
{ void client::Set_SteamAPI_CPostAPIResultInProcess(void* func)
OutputDebugStringA(__FUNCTION__); {
return true; }
}
void client::Remove_SteamAPI_CPostAPIResultInProcess(void* func)
void* client::GetISteamHTTP(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion) {
{ }
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion); void client::Set_SteamAPI_CCheckCallbackRegisteredInProcess(void* func)
//MessageBoxA(0, pchVersion, 0, 0); {
}
static http h;
return &h; void* client::GetISteamInventory(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
} {
return get_dummy();
void* client::GetISteamUnifiedMessages(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion) }
{
OutputDebugStringA(__FUNCTION__); void* client::GetISteamVideo(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
OutputDebugStringA(pchVersion); {
return get_dummy(); //
static unified_messages u; }
return &u; //
} void* client::GetISteamParentalSettings(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
void* client::GetISteamController(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion) return get_dummy();
{ }
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
static controller c;
return &c; //
}
void* client::GetISteamUGC(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy(); //
}
void* client::GetISteamAppList(HSteamUser hSteamUser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy(); //
}
void* client::GetISteamMusic(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy(); //
}
void* client::GetISteamMusicRemote(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy(); //
}
void* client::GetISteamHTMLSurface(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy(); //
}
void client::Set_SteamAPI_CPostAPIResultInProcess(void* func)
{
OutputDebugStringA(__FUNCTION__);
}
void client::Remove_SteamAPI_CPostAPIResultInProcess(void* func)
{
OutputDebugStringA(__FUNCTION__);
}
void client::Set_SteamAPI_CCheckCallbackRegisteredInProcess(void* func)
{
OutputDebugStringA(__FUNCTION__);
}
void* client::GetISteamInventory(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy();
}
void* client::GetISteamVideo(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy();//
}
void* client::GetISteamParentalSettings(HSteamUser hSteamuser, HSteamPipe hSteamPipe, const char* pchVersion)
{
OutputDebugStringA(__FUNCTION__);
OutputDebugStringA(pchVersion);
//MessageBoxA(0, pchVersion, 0, 0);
return get_dummy();
}
} }

4
src/client/steam/interfaces/client.hpp
View File

@ -3,8 +3,8 @@
namespace steam namespace steam
{ {
using HSteamPipe = uint64_t; using HSteamPipe = uint64_t;
using HSteamUser = uint64_t; using HSteamUser = uint64_t;
class client class client
{ {

130
src/client/steam/interfaces/controller.cpp
View File

@ -3,72 +3,82 @@
namespace steam namespace steam
{ {
bool controller::Init() bool controller::Init()
{ {
return true; return true;
} }
bool controller::Shutdown()
{
return true;
}
void controller::RunFrame() bool controller::Shutdown()
{ {
return true;
}
} void controller::RunFrame()
int controller::GetConnectedControllers(ControllerHandle_t* handlesOut) {
{ }
return 0;
}
bool controller::ShowBindingPanel(ControllerHandle_t controllerHandle) int controller::GetConnectedControllers(ControllerHandle_t* handlesOut)
{ {
return false; return 0;
} }
uint64_t controller::GetActionSetHandle(const char* pszActionSetName)
{
return 0;
}
void controller::ActivateActionSet(ControllerHandle_t controllerHandle, uint64_t actionSetHandle)
{
} bool controller::ShowBindingPanel(ControllerHandle_t controllerHandle)
uint64_t controller::GetCurrentActionSet(ControllerHandle_t controllerHandle) {
{ return false;
return 0; }
}
uint64_t controller::GetDigitalActionHandle(const char* pszActionName)
{
return 0;
}
uint64_t controller::GetDigitalActionData(ControllerHandle_t controllerHandle, uint64_t digitalActionHandle) uint64_t controller::GetActionSetHandle(const char* pszActionSetName)
{ {
return 0; return 0;
} }
int controller::GetDigitalActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle, uint64_t digitalActionHandle, uint64_t* originsOut)
{
return 0;
}
uint64_t controller::GetAnalogActionHandle(const char* pszActionName)
{
return 0;
}
uint64_t controller::GetAnalogActionData(ControllerHandle_t controllerHandle, uint64_t analogActionHandle)
{
return 0;
}
int controller::GetAnalogActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle, uint64_t analogActionHandle, uint64_t* originsOut)
{
return 0;
}
void controller::StopAnalogActionMomentum(ControllerHandle_t controllerHandle, uint64_t eAction)
{
} void controller::ActivateActionSet(ControllerHandle_t controllerHandle, uint64_t actionSetHandle)
{
}
void controller::TriggerHapticPulse(ControllerHandle_t controllerHandle, uint64_t eTargetPad, unsigned short usDurationMicroSec) uint64_t controller::GetCurrentActionSet(ControllerHandle_t controllerHandle)
{ {
return 0;
}
} uint64_t controller::GetDigitalActionHandle(const char* pszActionName)
{
return 0;
}
uint64_t controller::GetDigitalActionData(ControllerHandle_t controllerHandle, uint64_t digitalActionHandle)
{
return 0;
}
int controller::GetDigitalActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle,
uint64_t digitalActionHandle, uint64_t* originsOut)
{
return 0;
}
uint64_t controller::GetAnalogActionHandle(const char* pszActionName)
{
return 0;
}
uint64_t controller::GetAnalogActionData(ControllerHandle_t controllerHandle, uint64_t analogActionHandle)
{
return 0;
}
int controller::GetAnalogActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle,
uint64_t analogActionHandle, uint64_t* originsOut)
{
return 0;
}
void controller::StopAnalogActionMomentum(ControllerHandle_t controllerHandle, uint64_t eAction)
{
}
void controller::TriggerHapticPulse(ControllerHandle_t controllerHandle, uint64_t eTargetPad,
unsigned short usDurationMicroSec)
{
}
} }

12
src/client/steam/interfaces/controller.hpp
View File

@ -2,7 +2,8 @@
namespace steam namespace steam
{ {
using ControllerHandle_t = uint64_t; using ControllerHandle_t = uint64_t;
class controller class controller
{ {
public: public:
@ -18,11 +19,14 @@ namespace steam
virtual uint64_t GetCurrentActionSet(ControllerHandle_t controllerHandle); virtual uint64_t GetCurrentActionSet(ControllerHandle_t controllerHandle);
virtual uint64_t GetDigitalActionHandle(const char* pszActionName); virtual uint64_t GetDigitalActionHandle(const char* pszActionName);
virtual uint64_t GetDigitalActionData(ControllerHandle_t controllerHandle, uint64_t digitalActionHandle); virtual uint64_t GetDigitalActionData(ControllerHandle_t controllerHandle, uint64_t digitalActionHandle);
virtual int GetDigitalActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle, uint64_t digitalActionHandle, uint64_t* originsOut); virtual int GetDigitalActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle,
uint64_t digitalActionHandle, uint64_t* originsOut);
virtual uint64_t GetAnalogActionHandle(const char* pszActionName); virtual uint64_t GetAnalogActionHandle(const char* pszActionName);
virtual uint64_t GetAnalogActionData(ControllerHandle_t controllerHandle, uint64_t analogActionHandle); virtual uint64_t GetAnalogActionData(ControllerHandle_t controllerHandle, uint64_t analogActionHandle);
virtual int GetAnalogActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle, uint64_t analogActionHandle, uint64_t* originsOut); virtual int GetAnalogActionOrigins(ControllerHandle_t controllerHandle, uint64_t actionSetHandle,
uint64_t analogActionHandle, uint64_t* originsOut);
virtual void StopAnalogActionMomentum(ControllerHandle_t controllerHandle, uint64_t eAction); virtual void StopAnalogActionMomentum(ControllerHandle_t controllerHandle, uint64_t eAction);
virtual void TriggerHapticPulse(ControllerHandle_t controllerHandle, uint64_t eTargetPad, unsigned short usDurationMicroSec); virtual void TriggerHapticPulse(ControllerHandle_t controllerHandle, uint64_t eTargetPad,
unsigned short usDurationMicroSec);
}; };
} }

84
src/client/steam/interfaces/game_server_stats.cpp
View File

@ -1,56 +1,56 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../steam.hpp" #include "../steam.hpp"
namespace steam { namespace steam
uint64_t game_server_stats::RequestUserStats(steam_id steamIDUser)
{ {
return 0; uint64_t game_server_stats::RequestUserStats(steam_id steamIDUser)
} {
return 0;
}
bool game_server_stats::GetUserStat(steam_id steamIDUser, const char* pchName, int32_t* pData) bool game_server_stats::GetUserStat(steam_id steamIDUser, const char* pchName, int32_t* pData)
{ {
return false; return false;
} }
bool game_server_stats::GetUserStat(steam_id steamIDUser, const char* pchName, float* pData) bool game_server_stats::GetUserStat(steam_id steamIDUser, const char* pchName, float* pData)
{ {
return false; return false;
} }
bool game_server_stats::GetUserAchievement(steam_id steamIDUser, const char* pchName, bool* pbAchieved) bool game_server_stats::GetUserAchievement(steam_id steamIDUser, const char* pchName, bool* pbAchieved)
{ {
return false; return false;
} }
bool game_server_stats::SetUserStat(steam_id steamIDUser, const char* pchName, int32_t nData) bool game_server_stats::SetUserStat(steam_id steamIDUser, const char* pchName, int32_t nData)
{ {
return false; return false;
} }
bool game_server_stats::SetUserStat(steam_id steamIDUser, const char* pchName, float fData) bool game_server_stats::SetUserStat(steam_id steamIDUser, const char* pchName, float fData)
{ {
return false; return false;
} }
bool game_server_stats::UpdateUserAvgRateStat(steam_id steamIDUser, const char* pchName, float flCountThisSession, bool game_server_stats::UpdateUserAvgRateStat(steam_id steamIDUser, const char* pchName, float flCountThisSession,
double dSessionLength) double dSessionLength)
{ {
return false; return false;
} }
bool game_server_stats::SetUserAchievement(steam_id steamIDUser, const char* pchName) bool game_server_stats::SetUserAchievement(steam_id steamIDUser, const char* pchName)
{ {
return false; return false;
} }
bool game_server_stats::ClearUserAchievement(steam_id steamIDUser, const char* pchName) bool game_server_stats::ClearUserAchievement(steam_id steamIDUser, const char* pchName)
{ {
return false; return false;
} }
uint64_t game_server_stats::StoreUserStats(steam_id steamIDUser)
{
return 0;
}
uint64_t game_server_stats::StoreUserStats(steam_id steamIDUser)
{
return 0;
}
} }

3
src/client/steam/interfaces/game_server_stats.hpp
View File

@ -13,7 +13,8 @@ namespace steam
virtual bool GetUserAchievement(steam_id steamIDUser, const char* pchName, bool* pbAchieved); virtual bool GetUserAchievement(steam_id steamIDUser, const char* pchName, bool* pbAchieved);
virtual bool SetUserStat(steam_id steamIDUser, const char* pchName, int32_t nData); virtual bool SetUserStat(steam_id steamIDUser, const char* pchName, int32_t nData);
virtual bool SetUserStat(steam_id steamIDUser, const char* pchName, float fData); virtual bool SetUserStat(steam_id steamIDUser, const char* pchName, float fData);
virtual bool UpdateUserAvgRateStat(steam_id steamIDUser, const char* pchName, float flCountThisSession, double dSessionLength); virtual bool UpdateUserAvgRateStat(steam_id steamIDUser, const char* pchName, float flCountThisSession,
double dSessionLength);
virtual bool SetUserAchievement(steam_id steamIDUser, const char* pchName); virtual bool SetUserAchievement(steam_id steamIDUser, const char* pchName);
virtual bool ClearUserAchievement(steam_id steamIDUser, const char* pchName); virtual bool ClearUserAchievement(steam_id steamIDUser, const char* pchName);
virtual uint64_t StoreUserStats(steam_id steamIDUser); virtual uint64_t StoreUserStats(steam_id steamIDUser);

208
src/client/steam/interfaces/http.cpp
View File

@ -1,131 +1,137 @@
#include <std_include.hpp> #include <std_include.hpp>
#include "../steam.hpp" #include "../steam.hpp"
namespace steam namespace steam
{ {
HTTPRequestHandle http::http::CreateHTTPRequest(uint32_t eHTTPRequestMethod, const char* pchAbsoluteURL) HTTPRequestHandle http::http::CreateHTTPRequest(uint32_t eHTTPRequestMethod, const char* pchAbsoluteURL)
{ {
return 0; return 0;
} }
bool http::SetHTTPRequestContextValue(HTTPRequestHandle hRequest, uint64_t ulContextValue) bool http::SetHTTPRequestContextValue(HTTPRequestHandle hRequest, uint64_t ulContextValue)
{ {
return false; return false;
} }
bool http::SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint32_t unTimeoutSeconds) bool http::SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint32_t unTimeoutSeconds)
{ {
return false; return false;
} }
bool http::SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName, const char* pchHeaderValue) bool http::SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName,
{ const char* pchHeaderValue)
return false; {
} return false;
}
bool http::SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, const char* pchParamName, const char* pchParamValue) bool http::SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, const char* pchParamName,
{ const char* pchParamValue)
return false; {
} return false;
}
bool http::SendHTTPRequest(HTTPRequestHandle hRequest, uint64_t* pCallHandle) bool http::SendHTTPRequest(HTTPRequestHandle hRequest, uint64_t* pCallHandle)
{ {
return false; return false;
} }
bool http::SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, uint64_t* pCallHandle) bool http::SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, uint64_t* pCallHandle)
{ {
return false; return false;
} }
bool http::DeferHTTPRequest(HTTPRequestHandle hRequest) bool http::DeferHTTPRequest(HTTPRequestHandle hRequest)
{ {
return false; return false;
} }
bool http::PrioritizeHTTPRequest(HTTPRequestHandle hRequest) bool http::PrioritizeHTTPRequest(HTTPRequestHandle hRequest)
{ {
return false; return false;
} }
bool http::GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, const char* pchHeaderName, uint32_t* unResponseHeaderSize) bool http::GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, const char* pchHeaderName,
{ uint32_t* unResponseHeaderSize)
return false; {
} return false;
}
bool http::GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName, uint8_t* pHeaderValueBuffer, uint32_t unBufferSize) bool http::GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName,
{ uint8_t* pHeaderValueBuffer, uint32_t unBufferSize)
return false; {
} return false;
}
bool http::GetHTTPResponseBodySize(HTTPRequestHandle hRequest, uint32_t* unBodySize) bool http::GetHTTPResponseBodySize(HTTPRequestHandle hRequest, uint32_t* unBodySize)
{ {
return false; return false;
} }
bool http::GetHTTPResponseBodyData(HTTPRequestHandle hRequest, uint8_t* pBodyDataBuffer, uint32_t unBufferSize) bool http::GetHTTPResponseBodyData(HTTPRequestHandle hRequest, uint8_t* pBodyDataBuffer, uint32_t unBufferSize)
{ {
return false; return false;
} }
bool http::GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint32_t cOffset, uint8_t* pBodyDataBuffer, uint32_t unBufferSize) bool http::GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint32_t cOffset, uint8_t* pBodyDataBuffer,
{ uint32_t unBufferSize)
return false; {
} return false;
}
bool http::ReleaseHTTPRequest(HTTPRequestHandle hRequest) bool http::ReleaseHTTPRequest(HTTPRequestHandle hRequest)
{ {
return false; return false;
} }
bool http::GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, float* pflPercentOut) bool http::GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, float* pflPercentOut)
{ {
return false; return false;
} }
bool http::SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, const char* pchContentType, uint8_t* pubBody, uint32_t unBodyLen) bool http::SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, const char* pchContentType, uint8_t* pubBody,
{ uint32_t unBodyLen)
return false; {
} return false;
}
HTTPCookieContainerHandle http::CreateCookieContainer(bool bAllowResponsesToModify) HTTPCookieContainerHandle http::CreateCookieContainer(bool bAllowResponsesToModify)
{ {
return 0; return 0;
} }
bool http::ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer) bool http::ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer)
{ {
return false; return false;
} }
bool http::SetCookie(HTTPCookieContainerHandle hCookieContainer, const char* pchHost, const char* pchUrl, const char* pchCookie) bool http::SetCookie(HTTPCookieContainerHandle hCookieContainer, const char* pchHost, const char* pchUrl,
{ const char* pchCookie)
return false; {
} return false;
}
bool http::SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer) bool http::SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer)
{ {
return false; return false;
} }
bool http::SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, const char* pchUserAgentInfo) bool http::SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, const char* pchUserAgentInfo)
{ {
return false; return false;
} }
bool http::SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate) bool http::SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate)
{ {
return false; return false;
} }
bool http::SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint32_t unMilliseconds) bool http::SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint32_t unMilliseconds)
{ {
return false; return false;
} }
bool http::GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, bool* pbWasTimedOut) bool http::GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, bool* pbWasTimedOut)
{ {
return false; return false;
} }
} }

34
src/client/steam/interfaces/http.hpp
View File

@ -2,8 +2,8 @@
namespace steam namespace steam
{ {
using HTTPRequestHandle = uint64_t; using HTTPRequestHandle = uint64_t;
using HTTPCookieContainerHandle = uint64_t; using HTTPCookieContainerHandle = uint64_t;
class http class http
{ {
@ -13,26 +13,36 @@ namespace steam
virtual HTTPRequestHandle CreateHTTPRequest(uint32_t eHTTPRequestMethod, const char* pchAbsoluteURL); virtual HTTPRequestHandle CreateHTTPRequest(uint32_t eHTTPRequestMethod, const char* pchAbsoluteURL);
virtual bool SetHTTPRequestContextValue(HTTPRequestHandle hRequest, uint64_t ulContextValue); virtual bool SetHTTPRequestContextValue(HTTPRequestHandle hRequest, uint64_t ulContextValue);
virtual bool SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint32_t unTimeoutSeconds); virtual bool SetHTTPRequestNetworkActivityTimeout(HTTPRequestHandle hRequest, uint32_t unTimeoutSeconds);
virtual bool SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName, const char* pchHeaderValue); virtual bool SetHTTPRequestHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName,
virtual bool SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, const char* pchParamName, const char* pchParamValue); const char* pchHeaderValue);
virtual bool SetHTTPRequestGetOrPostParameter(HTTPRequestHandle hRequest, const char* pchParamName,
const char* pchParamValue);
virtual bool SendHTTPRequest(HTTPRequestHandle hRequest, uint64_t* pCallHandle); virtual bool SendHTTPRequest(HTTPRequestHandle hRequest, uint64_t* pCallHandle);
virtual bool SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, uint64_t* pCallHandle); virtual bool SendHTTPRequestAndStreamResponse(HTTPRequestHandle hRequest, uint64_t* pCallHandle);
virtual bool DeferHTTPRequest(HTTPRequestHandle hRequest); virtual bool DeferHTTPRequest(HTTPRequestHandle hRequest);
virtual bool PrioritizeHTTPRequest(HTTPRequestHandle hRequest); virtual bool PrioritizeHTTPRequest(HTTPRequestHandle hRequest);
virtual bool GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, const char* pchHeaderName, uint32_t* unResponseHeaderSize); virtual bool GetHTTPResponseHeaderSize(HTTPRequestHandle hRequest, const char* pchHeaderName,
virtual bool GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName, uint8_t* pHeaderValueBuffer, uint32_t unBufferSize); uint32_t* unResponseHeaderSize);
virtual bool GetHTTPResponseHeaderValue(HTTPRequestHandle hRequest, const char* pchHeaderName,
uint8_t* pHeaderValueBuffer, uint32_t unBufferSize);
virtual bool GetHTTPResponseBodySize(HTTPRequestHandle hRequest, uint32_t* unBodySize); virtual bool GetHTTPResponseBodySize(HTTPRequestHandle hRequest, uint32_t* unBodySize);
virtual bool GetHTTPResponseBodyData(HTTPRequestHandle hRequest, uint8_t* pBodyDataBuffer, uint32_t unBufferSize); virtual bool GetHTTPResponseBodyData(HTTPRequestHandle hRequest, uint8_t* pBodyDataBuffer,
virtual bool GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint32_t cOffset, uint8_t* pBodyDataBuffer, uint32_t unBufferSize); uint32_t unBufferSize);
virtual bool GetHTTPStreamingResponseBodyData(HTTPRequestHandle hRequest, uint32_t cOffset,
uint8_t* pBodyDataBuffer, uint32_t unBufferSize);
virtual bool ReleaseHTTPRequest(HTTPRequestHandle hRequest); virtual bool ReleaseHTTPRequest(HTTPRequestHandle hRequest);
virtual bool GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, float* pflPercentOut); virtual bool GetHTTPDownloadProgressPct(HTTPRequestHandle hRequest, float* pflPercentOut);
virtual bool SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, const char* pchContentType, uint8_t* pubBody, uint32_t unBodyLen); virtual bool SetHTTPRequestRawPostBody(HTTPRequestHandle hRequest, const char* pchContentType, uint8_t* pubBody,
uint32_t unBodyLen);
virtual HTTPCookieContainerHandle CreateCookieContainer(bool bAllowResponsesToModify); virtual HTTPCookieContainerHandle CreateCookieContainer(bool bAllowResponsesToModify);
virtual bool ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer); virtual bool ReleaseCookieContainer(HTTPCookieContainerHandle hCookieContainer);
virtual bool SetCookie(HTTPCookieContainerHandle hCookieContainer, const char* pchHost, const char* pchUrl, const char* pchCookie); virtual bool SetCookie(HTTPCookieContainerHandle hCookieContainer, const char* pchHost, const char* pchUrl,
virtual bool SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest, HTTPCookieContainerHandle hCookieContainer); const char* pchCookie);
virtual bool SetHTTPRequestCookieContainer(HTTPRequestHandle hRequest,
HTTPCookieContainerHandle hCookieContainer);
virtual bool SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, const char* pchUserAgentInfo); virtual bool SetHTTPRequestUserAgentInfo(HTTPRequestHandle hRequest, const char* pchUserAgentInfo);
virtual bool SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest, bool bRequireVerifiedCertificate); virtual bool SetHTTPRequestRequiresVerifiedCertificate(HTTPRequestHandle hRequest,
bool bRequireVerifiedCertificate);
virtual bool SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint32_t unMilliseconds); virtual bool SetHTTPRequestAbsoluteTimeoutMS(HTTPRequestHandle hRequest, uint32_t unMilliseconds);
virtual bool GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, bool* pbWasTimedOut); virtual bool GetHTTPRequestWasTimedOut(HTTPRequestHandle hRequest, bool* pbWasTimedOut);
}; };

55
src/client/steam/interfaces/screenshots.cpp
View File

@ -3,38 +3,37 @@
namespace steam namespace steam
{ {
uint64_t screenshots::WriteScreenshot(void* pubRGB, uint32_t cubRGB, int nWidth, int nHeight) uint64_t screenshots::WriteScreenshot(void* pubRGB, uint32_t cubRGB, int nWidth, int nHeight)
{ {
return 0; return 0;
} }
uint64_t screenshots::AddScreenshotToLibrary(const char* pchFilename, const char* pchThumbnailFilename, int nWidth, int nHeight) uint64_t screenshots::AddScreenshotToLibrary(const char* pchFilename, const char* pchThumbnailFilename, int nWidth,
{ int nHeight)
return 0; {
} return 0;
}
void screenshots::TriggerScreenshot() void screenshots::TriggerScreenshot()
{ {
}
} void screenshots::HookScreenshots(bool bHook)
{
}
void screenshots::HookScreenshots(bool bHook) bool screenshots::SetLocation(uint64_t hScreenshot, const char* pchLocation)
{ {
return false;
}
} bool screenshots::TagUser(uint64_t hScreenshot, steam_id steamID)
{
return false;
}
bool screenshots::SetLocation(uint64_t hScreenshot, const char* pchLocation) bool screenshots::TagPublishedFile(uint64_t hScreenshot, uint64_t unPublishedFileID)
{ {
return false; return false;
} }
bool screenshots::TagUser(uint64_t hScreenshot, steam_id steamID)
{
return false;
}
bool screenshots::TagPublishedFile(uint64_t hScreenshot, uint64_t unPublishedFileID)
{
return false;
}
} }

3
src/client/steam/interfaces/screenshots.hpp
View File

@ -8,7 +8,8 @@ namespace steam
~screenshots() = default; ~screenshots() = default;
virtual uint64_t WriteScreenshot(void* pubRGB, uint32_t cubRGB, int nWidth, int nHeight); virtual uint64_t WriteScreenshot(void* pubRGB, uint32_t cubRGB, int nWidth, int nHeight);
virtual uint64_t AddScreenshotToLibrary(const char* pchFilename, const char* pchThumbnailFilename, int nWidth, int nHeight); virtual uint64_t AddScreenshotToLibrary(const char* pchFilename, const char* pchThumbnailFilename, int nWidth,
int nHeight);
virtual void TriggerScreenshot(); virtual void TriggerScreenshot();
virtual void HookScreenshots(bool bHook); virtual void HookScreenshots(bool bHook);
virtual bool SetLocation(uint64_t hScreenshot, const char* pchLocation); virtual bool SetLocation(uint64_t hScreenshot, const char* pchLocation);

44
src/client/steam/interfaces/unified_messages.cpp
View File

@ -3,28 +3,32 @@
namespace steam namespace steam
{ {
ClientUnifiedMessageHandle unified_messages::SendMethod(const char* pchServiceMethod, const void* pRequestBuffer, uint32_t unRequestBufferSize, uint64_t unContext) ClientUnifiedMessageHandle unified_messages::SendMethod(const char* pchServiceMethod, const void* pRequestBuffer,
{ uint32_t unRequestBufferSize, uint64_t unContext)
return 0; {
} return 0;
}
bool unified_messages::GetMethodResponseInfo(ClientUnifiedMessageHandle hHandle, uint32_t* punResponseSize, uint32_t* peResult) bool unified_messages::GetMethodResponseInfo(ClientUnifiedMessageHandle hHandle, uint32_t* punResponseSize,
{ uint32_t* peResult)
return false; {
} return false;
}
bool unified_messages::GetMethodResponseData(ClientUnifiedMessageHandle hHandle, void* pResponseBuffer, uint32_t unResponseBufferSize, bool bAutoRelease) bool unified_messages::GetMethodResponseData(ClientUnifiedMessageHandle hHandle, void* pResponseBuffer,
{ uint32_t unResponseBufferSize, bool bAutoRelease)
return false; {
} return false;
}
bool unified_messages::ReleaseMethod(ClientUnifiedMessageHandle hHandle) bool unified_messages::ReleaseMethod(ClientUnifiedMessageHandle hHandle)
{ {
return false; return false;
} }
bool unified_messages::SendNotification(const char* pchServiceNotification, const void* pNotificationBuffer, uint32_t unNotificationBufferSize) bool unified_messages::SendNotification(const char* pchServiceNotification, const void* pNotificationBuffer,
{ uint32_t unNotificationBufferSize)
return false; {
} return false;
}
} }

14
src/client/steam/interfaces/unified_messages.hpp
View File

@ -2,17 +2,21 @@
namespace steam namespace steam
{ {
using ClientUnifiedMessageHandle = uint64_t; using ClientUnifiedMessageHandle = uint64_t;
class unified_messages class unified_messages
{ {
public: public:
~unified_messages() = default; ~unified_messages() = default;
virtual ClientUnifiedMessageHandle SendMethod(const char* pchServiceMethod, const void* pRequestBuffer, uint32_t unRequestBufferSize, uint64_t unContext); virtual ClientUnifiedMessageHandle SendMethod(const char* pchServiceMethod, const void* pRequestBuffer,
virtual bool GetMethodResponseInfo(ClientUnifiedMessageHandle hHandle, uint32_t* punResponseSize, uint32_t* peResult); uint32_t unRequestBufferSize, uint64_t unContext);
virtual bool GetMethodResponseData(ClientUnifiedMessageHandle hHandle, void* pResponseBuffer, uint32_t unResponseBufferSize, bool bAutoRelease); virtual bool GetMethodResponseInfo(ClientUnifiedMessageHandle hHandle, uint32_t* punResponseSize,
uint32_t* peResult);
virtual bool GetMethodResponseData(ClientUnifiedMessageHandle hHandle, void* pResponseBuffer,
uint32_t unResponseBufferSize, bool bAutoRelease);
virtual bool ReleaseMethod(ClientUnifiedMessageHandle hHandle); virtual bool ReleaseMethod(ClientUnifiedMessageHandle hHandle);
virtual bool SendNotification(const char* pchServiceNotification, const void* pNotificationBuffer, uint32_t unNotificationBufferSize); virtual bool SendNotification(const char* pchServiceNotification, const void* pNotificationBuffer,
uint32_t unNotificationBufferSize);
}; };
} }

59
src/client/steam/interfaces/user.cpp
View File

@ -139,7 +139,8 @@ namespace steam
// Create the call response // Create the call response
const auto result = callbacks::register_call(); const auto result = callbacks::register_call();
const auto retvals = static_cast<encrypted_app_ticket_response*>(calloc(1, sizeof(encrypted_app_ticket_response))); const auto retvals = static_cast<encrypted_app_ticket_response*>(calloc(
1, sizeof(encrypted_app_ticket_response)));
//::Utils::Memory::AllocateArray<EncryptedAppTicketResponse>(); //::Utils::Memory::AllocateArray<EncryptedAppTicketResponse>();
retvals->m_e_result = 1; retvals->m_e_result = 1;
@ -161,34 +162,38 @@ namespace steam
return true; return true;
} }
int user::GetGameBadgeLevel(int nSeries, bool bFoil) int user::GetGameBadgeLevel(int nSeries, bool bFoil)
{ {
return 1; return 1;
} }
int user::GetPlayerSteamLevel()
{
return 0;
}
uint64_t user::RequestStoreAuthURL(const char* pchRedirectURL)
{
return 0;
}
bool user::BIsPhoneVerified()
{
return true;
}
bool user::BIsTwoFactorEnabled() int user::GetPlayerSteamLevel()
{ {
return true; return 0;
} }
bool user::BIsPhoneIdentifying() uint64_t user::RequestStoreAuthURL(const char* pchRedirectURL)
{ {
return false; return 0;
} }
bool user::BIsPhoneRequiringVerification()
{ bool user::BIsPhoneVerified()
return false; {
} return true;
}
bool user::BIsTwoFactorEnabled()
{
return true;
}
bool user::BIsPhoneIdentifying()
{
return false;
}
bool user::BIsPhoneRequiringVerification()
{
return false;
}
} }

80
src/client/steam/steam.cpp
View File

@ -105,13 +105,11 @@ namespace steam
bool SteamAPI_RestartAppIfNecessary() bool SteamAPI_RestartAppIfNecessary()
{ {
OutputDebugStringA(__FUNCTION__);
return false; return false;
} }
bool SteamAPI_Init() bool SteamAPI_Init()
{ {
OutputDebugStringA(__FUNCTION__);
const std::filesystem::path steam_path = steam::SteamAPI_GetSteamInstallPath(); const std::filesystem::path steam_path = steam::SteamAPI_GetSteamInstallPath();
if (steam_path.empty()) return true; if (steam_path.empty()) return true;
@ -124,42 +122,35 @@ namespace steam
void SteamAPI_RegisterCallResult(callbacks::base* result, const uint64_t call) void SteamAPI_RegisterCallResult(callbacks::base* result, const uint64_t call)
{ {
OutputDebugStringA(__FUNCTION__);
callbacks::register_call_result(call, result); callbacks::register_call_result(call, result);
} }
void SteamAPI_RegisterCallback(callbacks::base* handler, const int callback) void SteamAPI_RegisterCallback(callbacks::base* handler, const int callback)
{ {
OutputDebugStringA(__FUNCTION__);
callbacks::register_callback(handler, callback); callbacks::register_callback(handler, callback);
} }
void SteamAPI_RunCallbacks() void SteamAPI_RunCallbacks()
{ {
OutputDebugStringA(__FUNCTION__);
callbacks::run_callbacks(); callbacks::run_callbacks();
} }
void SteamAPI_Shutdown() void SteamAPI_Shutdown()
{ {
OutputDebugStringA(__FUNCTION__);
} }
void SteamAPI_UnregisterCallResult(callbacks::base* result, const uint64_t call) void SteamAPI_UnregisterCallResult(callbacks::base* result, const uint64_t call)
{ {
OutputDebugStringA(__FUNCTION__);
callbacks::unregister_call_result(call, result); callbacks::unregister_call_result(call, result);
} }
void SteamAPI_UnregisterCallback(callbacks::base* handler) void SteamAPI_UnregisterCallback(callbacks::base* handler)
{ {
OutputDebugStringA(__FUNCTION__);
callbacks::unregister_callback(handler); callbacks::unregister_callback(handler);
} }
const char* SteamAPI_GetSteamInstallPath() const char* SteamAPI_GetSteamInstallPath()
{ {
OutputDebugStringA(__FUNCTION__);
static std::string install_path{}; static std::string install_path{};
if (!install_path.empty()) if (!install_path.empty())
{ {
@ -182,126 +173,109 @@ namespace steam
return install_path.data(); return install_path.data();
} }
void* SteamGameServer_GetHSteamPipe()
void* SteamGameServer_GetHSteamPipe()
{ {
OutputDebugStringA(__FUNCTION__); return reinterpret_cast<void*>(1);
return (void*)1;
} }
void* SteamGameServer_GetHSteamUser() void* SteamGameServer_GetHSteamUser()
{ {
OutputDebugStringA(__FUNCTION__); return reinterpret_cast<void*>(1);
return (void*)1;
} }
void* SteamAPI_GetHSteamUser() void* SteamAPI_GetHSteamUser()
{
OutputDebugStringA(__FUNCTION__);
return (void*)1;
}
void* SteamAPI_GetHSteamPipe()
{
OutputDebugStringA(__FUNCTION__);
return (void*)1;
}
void* SteamInternal_CreateInterface(const char* interfacename)
{ {
OutputDebugStringA(__FUNCTION__); return reinterpret_cast<void*>(1);
OutputDebugStringA(interfacename);
if(std::string(interfacename) == "SteamClient017") {
static client c;
return &c;
}
MessageBoxA(0, interfacename, __FUNCTION__, 0);
return nullptr;//::utils::nt::library("steam_api64.dll").invoke<void*>("SteamInternal_CreateInterface", interfacename);
} }
bool SteamInternal_GameServer_Init() void* SteamAPI_GetHSteamPipe()
{ {
OutputDebugStringA(__FUNCTION__); return reinterpret_cast<void*>(1);
return true; }
void* SteamInternal_CreateInterface(const char* interfacename)
{
if (std::string(interfacename) == "SteamClient017")
{
static client c;
return &c;
}
MessageBoxA(0, interfacename, __FUNCTION__, 0);
return nullptr;
}
bool SteamInternal_GameServer_Init()
{
return true;
} }
bool SteamGameServer_Init() bool SteamGameServer_Init()
{ {
OutputDebugStringA(__FUNCTION__);
return true; return true;
} }
void SteamGameServer_RunCallbacks() void SteamGameServer_RunCallbacks()
{ {
OutputDebugStringA(__FUNCTION__);
} }
void SteamGameServer_Shutdown() void SteamGameServer_Shutdown()
{ {
OutputDebugStringA(__FUNCTION__);
} }
friends* SteamFriends() friends* SteamFriends()
{ {
OutputDebugStringA(__FUNCTION__);
static friends friends; static friends friends;
return &friends; return &friends;
} }
matchmaking* SteamMatchmaking() matchmaking* SteamMatchmaking()
{ {
OutputDebugStringA(__FUNCTION__);
static matchmaking matchmaking; static matchmaking matchmaking;
return &matchmaking; return &matchmaking;
} }
game_server* SteamGameServer() game_server* SteamGameServer()
{ {
OutputDebugStringA(__FUNCTION__);
static game_server game_server; static game_server game_server;
return &game_server; return &game_server;
} }
networking* SteamNetworking() networking* SteamNetworking()
{ {
OutputDebugStringA(__FUNCTION__);
static networking networking; static networking networking;
return &networking; return &networking;
} }
remote_storage* SteamRemoteStorage() remote_storage* SteamRemoteStorage()
{ {
OutputDebugStringA(__FUNCTION__);
static remote_storage remote_storage; static remote_storage remote_storage;
return &remote_storage; return &remote_storage;
} }
user* SteamUser() user* SteamUser()
{ {
OutputDebugStringA(__FUNCTION__);
static user user; static user user;
return &user; return &user;
} }
utils* SteamUtils() utils* SteamUtils()
{ {
OutputDebugStringA(__FUNCTION__);
static utils utils; static utils utils;
return &utils; return &utils;
} }
apps* SteamApps() apps* SteamApps()
{ {
OutputDebugStringA(__FUNCTION__);
static apps apps; static apps apps;
return &apps; return &apps;
} }
user_stats* SteamUserStats() user_stats* SteamUserStats()
{ {
OutputDebugStringA(__FUNCTION__);
static user_stats user_stats; static user_stats user_stats;
return &user_stats; return &user_stats;
} }