Controller.hpp

#pragma once
#include <Windows.h>
#include <iostream>
#include <thread>
#include <chrono>
#include <mutex>
#include <algorithm>
#include <Xinput.h>
#include <ViGEm/Client.h>

namespace ControllerAim {

    inline PVIGEM_CLIENT vigemClient = nullptr;
    inline PVIGEM_TARGET vigemTarget = nullptr;
    inline XUSB_REPORT controllerReport = { 0 };
    inline bool running = false;
    inline std::mutex controllerMutex;
    inline short aimbotRightStickX = 0;
    inline short aimbotRightStickY = 0;
    inline const float conversionFactor = 32767.0f / 127.0f;
    inline WORD extraButtons = 0;

    inline bool Initialize() {
        if (vigemClient != nullptr && vigemTarget != nullptr)
            return true;
        vigemClient = vigem_alloc();
        if (!vigemClient) {
            std::cerr << "Failed to allocate ViGEm client." << std::endl;
            return false;
        }
        VIGEM_ERROR ret = vigem_connect(vigemClient);
        if (!VIGEM_SUCCESS(ret)) {
            std::cerr << "Failed to connect ViGEm client. Error: " << ret << std::endl;
            vigem_free(vigemClient);
            vigemClient = nullptr;
            return false;
        }
        vigemTarget = vigem_target_x360_alloc();
        if (!vigemTarget) {
            std::cerr << "Failed to allocate virtual controller." << std::endl;
            vigem_disconnect(vigemClient);
            vigem_free(vigemClient);
            vigemClient = nullptr;
            return false;
        }
        ret = vigem_target_add(vigemClient, vigemTarget);
        if (!VIGEM_SUCCESS(ret)) {
            std::cerr << "Failed to add virtual controller. Error: " << ret << std::endl;
            vigem_target_free(vigemTarget);
            vigem_disconnect(vigemClient);
            vigem_free(vigemClient);
            vigemTarget = nullptr;
            vigemClient = nullptr;
            return false;
        }
        ZeroMemory(&controllerReport, sizeof(XUSB_REPORT));
        running = true;
        return true;
    }

    inline void Cleanup() {
        running = false;
        if (vigemClient && vigemTarget) {
            vigem_target_remove(vigemClient, vigemTarget);
            vigem_target_free(vigemTarget);
            vigemTarget = nullptr;
            vigem_disconnect(vigemClient);
            vigem_free(vigemClient);
            vigemClient = nullptr;
        }
    }

    inline void UpdateVirtualController() {
        VIGEM_ERROR ret = vigem_target_x360_update(vigemClient, vigemTarget, controllerReport);
        if (!VIGEM_SUCCESS(ret))
            std::cerr << "Failed to update virtual controller. Error: " << ret << std::endl;
    }

    inline void RunVirtualController() {
        if (!Initialize()) {
            std::cerr << "Virtual controller initialization failed." << std::endl;
            return;
        }
        std::cout << "Virtual controller thread running." << std::endl;
        XINPUT_STATE state;
        while (running) {
            ZeroMemory(&state, sizeof(XINPUT_STATE));
            DWORD result = XInputGetState(0, &state);
            int phys_RX = 0, phys_RY = 0;
            {
                std::lock_guard<std::mutex> lock(controllerMutex);
                if (result == ERROR_SUCCESS) {
                    const XINPUT_GAMEPAD& gamepad = state.Gamepad;
                    controllerReport.wButtons = gamepad.wButtons;
                    controllerReport.bLeftTrigger = gamepad.bLeftTrigger;
                    controllerReport.bRightTrigger = gamepad.bRightTrigger;
                    controllerReport.sThumbLX = gamepad.sThumbLX;
                    controllerReport.sThumbLY = gamepad.sThumbLY;
                    phys_RX = gamepad.sThumbRX;
                    phys_RY = gamepad.sThumbRY;
                }
                else {
                    controllerReport.wButtons = 0;
                    controllerReport.bLeftTrigger = 0;
                    controllerReport.bRightTrigger = 0;
                    controllerReport.sThumbLX = 0;
                    controllerReport.sThumbLY = 0;
                }
                int merged_RX = phys_RX + aimbotRightStickX;
                int merged_RY = phys_RY + aimbotRightStickY;
                controllerReport.sThumbRX = static_cast<short>(std::clamp(merged_RX, -32768, 32767));
                controllerReport.sThumbRY = static_cast<short>(std::clamp(merged_RY, -32768, 32767));

                //std::cout << "[XINPUT_GAMEPAD] Physical RX=" << phys_RX
                //    << ", Physical RY=" << phys_RY
                //    << " | Merged RX=" << controllerReport.sThumbRX
                //    << ", Merged RY=" << controllerReport.sThumbRY << std::endl;
            }
            VIGEM_ERROR ret = vigem_target_x360_update(vigemClient, vigemTarget, controllerReport);
            if (!VIGEM_SUCCESS(ret))
                std::cerr << "Failed to update virtual controller. Error: " << ret << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
        Cleanup();
    }

    /*inline void RunVirtualController() {
        if (!Initialize()) {
            std::cerr << "Virtual controller initialization failed." << std::endl;
            return;
        }
        std::cout << "Virtual controller thread running." << std::endl;
        XINPUT_STATE state;
        while (running) {
            ZeroMemory(&state, sizeof(XINPUT_STATE));
            DWORD result = XInputGetState(0, &state);
            int physButtons = 0;
            {
                std::lock_guard<std::mutex> lock(controllerMutex);
                if (result == ERROR_SUCCESS) {
                    const XINPUT_GAMEPAD& gamepad = state.Gamepad;
                    physButtons = gamepad.wButtons;
                    controllerReport.bLeftTrigger = gamepad.bLeftTrigger;
                    controllerReport.bRightTrigger = gamepad.bRightTrigger;
                    controllerReport.sThumbLX = gamepad.sThumbLX;
                    controllerReport.sThumbLY = gamepad.sThumbLY;
                    controllerReport.sThumbRX = gamepad.sThumbRX;
                    controllerReport.sThumbRY = gamepad.sThumbRY;
                }
                else {
                    controllerReport.bLeftTrigger = 0;
                    controllerReport.bRightTrigger = 0;
                    controllerReport.sThumbLX = 0;
                    controllerReport.sThumbLY = 0;
                    controllerReport.sThumbRX = 0;
                    controllerReport.sThumbRY = 0;
                }
                controllerReport.wButtons = static_cast<WORD>(physButtons | extraButtons);
            }
            VIGEM_ERROR ret = vigem_target_x360_update(vigemClient, vigemTarget, controllerReport);
            if (!VIGEM_SUCCESS(ret))
                std::cerr << "Failed to update virtual controller. Error: " << ret << std::endl;
            std::this_thread::sleep_for(std::chrono::milliseconds(10));
        }
        Cleanup();
    }

    inline void PressA() {
        while (running) {
            {
                std::lock_guard<std::mutex> lock(controllerMutex);
                extraButtons |= XINPUT_GAMEPAD_A;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
            {
                std::lock_guard<std::mutex> lock(controllerMutex);
                extraButtons &= ~XINPUT_GAMEPAD_A;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(900));
        }
    }*/


    inline std::thread LaunchVirtualController() {
        return std::thread(RunVirtualController);
    }

    inline void controller_move(float tarx, float tary, float screenX, float screenY, int smooth) {
        float centerX = screenX / 2.0f;
        float centerY = screenY / 2.0f;
        float deltaX = (tarx - centerX) / smooth;
        float deltaY = (tary - centerY) / smooth;
        // deltaY = -deltaY;

        const int min_mouse = -127;
        const int max_mouse = 127;
        int mouseDeltaX = static_cast<int>(std::clamp(deltaX, (float)min_mouse, (float)max_mouse));
        int mouseDeltaY = static_cast<int>(std::clamp(deltaY, (float)min_mouse, (float)max_mouse));
        const int min_xinput = -32768;
        const int max_xinput = 32767;
        const int deadzone = static_cast<int>(max_xinput * 0.1f);

        float scale = (max_xinput - deadzone) / static_cast<float>(max_mouse);

        int newRX, newRY;
        if (mouseDeltaX > 0) {
            newRX = static_cast<int>(mouseDeltaX * scale) + deadzone;
        }
        else if (mouseDeltaX < 0) {
            newRX = static_cast<int>(mouseDeltaX * scale) - deadzone;
        }
        else {
            newRX = 0;
        }
        if (mouseDeltaY > 0) {
            newRY = static_cast<int>(mouseDeltaY * scale) + deadzone;
        }
        else if (mouseDeltaY < 0) {
            newRY = static_cast<int>(mouseDeltaY * scale) - deadzone;
        }
        else {
            newRY = 0;
        }

        newRX = std::clamp(newRX, min_xinput, max_xinput);
        newRY = std::clamp(newRY, min_xinput, max_xinput);

        {
            std::lock_guard<std::mutex> lock(controllerMutex);
            aimbotRightStickX = static_cast<short>(newRX);
            aimbotRightStickY = static_cast<short>(newRY);
        }
        //std::cout << "[ControllerAim] Set Aimbot RS: tarx=" << tarx << ", tary=" << tary
            //<< " | Delta=(" << deltaX << ", " << deltaY << ")"
            //<< " -> newRX=" << newRX << ", newRY=" << newRY << std::endl;
        UpdateVirtualController();
    }

}