Function hook_steamclient_interface

src/steam_api/steam_interfaces.cpp:199–248

    }

    void hook_steamclient_interface(
        void* steamclient_handle,
        const std::string& steam_client_interface_version
    ) noexcept {
        try {
            // Create a copy for modification
            auto virtual_hook_map = get_virtual_hook_map();

            // Remove steam client map since we don't want to hook its methods
            virtual_hook_map.erase(STEAM_CLIENT);

            // Map virtual hook map to a set of keys
            const auto prefixes = std::views::keys(virtual_hook_map) | std::ranges::to<std::set>();

            const auto CreateInterface$ = KB_LIB_GET_FUNC(steamclient_handle, CreateInterface);

            DECLARE_ARGS();
            THIS = CreateInterface$(steam_client_interface_version.c_str(), nullptr);
            hook_virtuals(THIS, steam_client_interface_version);

            const auto interface_lookup = read_interface_lookup();
            for(const auto& interface_version : interface_lookup | std::views::keys) {
                // SteamUser and SteamPipe handles must match the ones previously used by the game,
                // otherwise SteamAPI will just create new instances of interfaces, instead of returning
                // existing instances that are used by the game. Usually these handles default to 1,
                // but if a game creates several of them, then we need to somehow find them out dynamically.
                constexpr auto steam_pipe = 1;
                constexpr auto steam_user = 1;

                bool should_hook = false;
                for(const auto& prefix : prefixes) {
                    if(interface_version.starts_with(prefix)) {
                        should_hook = true;
                        break;
                    }
                }

                if(not should_hook) {
                    continue;
                }

                ISteamClient_GetISteamGenericInterface(
                    ARGS(steam_user, steam_pipe, interface_version.c_str())
                );

            }
        } catch(const std::exception& e) {
            LOG_ERROR("{} -> Unhandled exception: {}", __func__, e.what());
        }
    }

    void* find_function(
        const void* instance_ptr,