Question

所以在这里，我试图制作一个程序，一些垃圾显示为错误。从来没有遇到这个，我不知道如何解决它。

我的代码：

#include <iostream>
#include <Windows.h>
#include <string>
#include <ctime>

void WriteToMemory(HANDLE hProcHandle);
DWORD FindDmaAddy(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress);

std::string GameName = "MicroVolts";
LPCSTR LGameWindow = "MicroVolts";
std::string GameStatus;

bool IsGameAvail;
bool UpdateOnNextRun;

bool MelleStatus;
int MelleValue[] = { 999999999 };
DWORD MelleBaseAddress = { 0x001DE5B8 };
DWORD MelleOffsets[] = { 0x270, 0x124, };

bool FireRateStatus;
int FireRateValue[] = { 0 };
DWORD FireRateBaseAddress = { 0x00D91150 };
DWORD FireRateOffsets[] = { 0x6C };

bool MellePowerStatus;
int MellePowerValue[] = { 999999999 };
DWORD MellePowerBaseAddress = { 0x001DE5B8 };
DWORD MellePowerOffsets[] = { 0x260, 0xC0 };

bool RiflePowerStatus;
int RiflePowerValue[] = { 999999999 };
DWORD RiflePowerBaseAddress = { 0x001DD838 };
DWORD RiflePowerOffsets[] = { 0x248, 0x254 };

bool SniperPowerStatus;
int SniperPowerValue[] = { 999999999 };
DWORD SniperPowerBaseAddress = { 0x001DD838 };
DWORD SniperPowerOffsets[] = { 0x248, 0x3E8 };

bool SniperPowerStatus;
int SniperPowerValue[] = { 999999999 };
DWORD SniperPowerBaseAddress = { 0x001DE5B8 };
DWORD SniperPowerOffsets[] = { 0x374, 0x57C };

bool BossStatus;
int BossValue[] = { 1 };
DWORD BossBaseAddress = { 0x00D978D0 };
DWORD BossPowerOffsets[] = { 0x404, 0x8 };

bool SpeedStatus;
float SpeedValue[] = { 430 };
DWORD SpeedBaseAddress = { 0xC1D708 };
DWORD SpeedOffsets[] = { 0x0 };

bool AutoCaptureStatus;
float AutoCaptureValue[] = { 5000000000 };
DWORD AutoCaptureBaseAddress = { 0xD7E4FC };
DWORD AutoCaptureOffsets[] = { 0x0 };

bool GravityStatus;
float GravityValue[] = { 250 };
DWORD GravityBaseAddress = { 0xD51D00 };
DWORD GravityPowerOffsets[] = { 0x0 };

bool AcuarityStatus;
double AcuarityValue[] = { 21 };
DWORD AcuarityBaseAddress = { 0xBA7FB0 };
DWORD AcuarityOffsets[] = { 0x0 };

int main()
{
HWND hGameWindow = NULL;
int timeSinceLastUpdate = clock();
int GameAvailTMR = clock();
int OnePressTMR;
DWORD dwProcId = NULL;
HANDLE hProcHandle = NULL;
UpdateOnNextRun = true;
std::string sMelleStatus;
std::string sFireRateStatus;
std::string sMellePowerStatus;
std::string sRiflePowerStatus;
std::string sShotgunPowerStatus;
std::string sSniperPowerStatus;
std::string sBossStatus;
std::string sSpeedStatus;
std::string sAutoCaptureStatus;
std::string sGravityStatus;
std::string sAcuarityStatus;
sMelleStatus = "OFF";
sFireRateStatus = "OFF";
sMellePowerStatus = "OFF";
sRiflePowerStatus = "OFF";
sShotgunPowerStatus = "OFF";
sSniperPowerStatus = "OFF";
sBossStatus = "OFF";
sSpeedStatus = "OFF";
sAutoCaptureStatus = "OFF";
sGravityStatus = "OFF";
sAcuarityStatus = "OFF";
OnePressTMR = clock();
while (!GetAsyncKeyState(VK_INSERT))
{
if (clock() - GameAvailTMR > 100)
    {
        GameAvailTMR = clock();
        IsGameAvail = false;
        hGameWindow = FindWindow(NULL, LGameWindow);
        if (hGameWindow)
        {
            GetWindowThreadProcessId(hGameWindow, &dwProcId);
            if (dwProcId != 0)
            {
                hProcHandle = OpenProcess(PROCESS_ALL_ACCESS, FALSE, dwProcId);
                if (hProcHandle == INVALID_HANDLE_VALUE || hProcHandle == NULL)
                {
                    GameStatus = "Failed to open process for valid handle";
                }
                else
                {
                    GameStatus = "MicroVolts is running!";
                    IsGameAvail = true;
                }
            }
            else GameStatus = "Failed to obtain process id";
        }
        else GameStatus = "MicroVolts not found";
        if (UpdateOnNextRun || clock() - timeSinceLastUpdate > 5000)
        {
            system("cls");
            std::cout << "----------------------------------------------------" << std::endl;
            std::cout << "                  Interium Mutihack                -" << std::endl;
            std::cout << "----------------------------------------------------" << std::endl << std::endl;
            std::cout << "Status:" << GameStatus << "   " << std::endl << std::endl;
            std::cout << "[F2] Melle Hack [" << sMelleStatus << " ]" << std::endl << std::endl;
            std::cout << "[F3] Weapon Booster [" << sFireRateStatus << "]" << std::endl << std::endl;
            std::cout << "[F4] Melle Power [" << sMellePowerStatus << "]Require Host" << std::endl << std::endl;
            std::cout << "[F5] Rifle Power [" << sRiflePowerStatus << "]Require Host" << std::endl << std::endl;
            std::cout << "[F6] Shotgun Power [" << sShotgunPowerStatus << "]Require Host" << std::endl << std::endl;
            std::cout << "[F7] Sniper Power [" << sSniperPowerStatus << "]Require Host" << std::endl << std::endl;
            std::cout << "[F8] Boss Hack [" << sBossStatus << "]Require Host" << std::endl << std::endl;
            std::cout << "[F9] Speed [" << sSpeedStatus << "]" << std::endl << std::endl;
            std::cout << "[F10] AutoCapture [" << sAutoCaptureStatus << "]" << std::endl << std::endl;
            std::cout << "[F11] Gravity [" << sGravityStatus << "]" << std::endl << std::endl;
            std::cout << "[F12] Acuarity [" << sAcuarityStatus << "]" << std::endl << std::endl;
            std::cout << "[INSERT] Exit" << std::endl;
            UpdateOnNextRun = true;
            timeSinceLastUpdate = clock();
        }

        if (IsGameAvail)
        {
            WriteToMemory(hProcHandle);
        }
    }


    if (clock() - OnePressTMR > 400)
    {
        if (IsGameAvail)
        {

            if (GetAsyncKeyState(VK_F2))
            {
                OnePressTMR = clock();

                MelleStatus = !MelleStatus;
                UpdateOnNextRun = true;

                if (MelleStatus)sMelleStatus = "ON";
                else sMelleStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F3))
            {
                OnePressTMR = clock();
                FireRateStatus = !FireRateStatus;
                UpdateOnNextRun = true;

                if (FireRateStatus)sFireRateStatus = "ON";
                else sFireRateStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F4))
            {
                OnePressTMR = clock();
                MellePowerStatus = !MellePowerStatus;
                UpdateOnNextRun = true;
                if (MellePowerStatus)
                {
                    sMellePowerStatus = "ON";
                }
                else sMellePowerStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F5))
            {
                OnePressTMR = clock();
                RiflePowerStatus = !RiflePowerStatus;
                UpdateOnNextRun = true;
                if (RiflePowerStatus)sRiflePowerStatus = "ON";
                else
                {
                sRiflePowerStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F6))
            {
                OnePressTMR = clock();
                ShotgunPowerStatus = !ShotgunPowerStatus
                    UpdateOnNextRun = true
                if (ShotgunPowerStatus)sShotgunPowerStatus = "ON";
                else sShotgunPowerStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F7))
            {
                OnePressTMR = clock();
                SniperPowerStatus = !SniperPowerStatus
                    UpdateOnNextRun = true
                if (SniperPowerStatus)sSniperPowerStatus = "ON";
                else sSniperPowerStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F8))
            {
                OnePressTMR = clock();
                BossStatus = !BossStatus
                    UpdateOnNextRun = true
                if (BossStatus)sBossStatus = "ON";
                else sBossStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F9))
            {
                OnePressTMR = clock();
                SpeedStatus = !SpeedStatus
                    UpdateOnNextRun = true
                if (SpeedStatus)sSpeedStatus = "ON";
                else sSpeedStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F10))
            {
                OnePressTMR = clock();
                AutoCaptureStatus = !AutoCaptureStatus
                    UpdateOnNextRun = true
                if (AutoCaptureStatus)sAutoCaptureStatus = "ON";
                else sAutoCaptureStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F11))
            {
                OnePressTMR = clock();
                GravityStatus = !GravityStatus
                    UpdateOnNextRun = true
                if (GravityStatus)sGravityStatus = "ON";
                else sGravityStatus = "OFF";
            }
            else if (GetAsyncKeyState(VK_F12))
            {
                OnePressTMR = clock();
                AcuarityPowerStatus = !AcuarityStatus
                    UpdateOnNextRun = true
                if (AcuarityStatus)sAcuarityStatus = "ON";
                else sAcuarityStatus = "OFF";
            }
        }
    }

    CloseHandle(hProcHandle);
    CloseHandle(hGameWindow);


    return ERROR_SUCCESS;
}

DWORD p(int PointerLevel, HANDLE hProcHandle, DWORD Offsets[], DWORD BaseAddress)
{
    DWORD pointer = BaseAddress;             
    DWORD pTemp;
    DWORD pointerAddr;
    for (int i = 0; i < PointerLevel; i++)
    {
        if (i == 0)
        {
            ReadProcessMemory(hProcHandle, (LPCVOID)pointer, &pTemp, 4, NULL);
        }
        pointerAddr = pTemp + Offsets[i];
        ReadProcessMemory(hProcHandle, (LPCVOID)pointerAddr, &pTemp, 4, NULL);
    }
    return pointerAddr;
}
void WriteToMemory(HANDLE hProcHandle)
{
    if (MelleStatus)
    {
        DWORD MelleAddressToWrite = FindDmaAddy(3, hProcHandle, MelleOffsets, MelleBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)MelleAddressToWrite, &MelleValue, sizeof(MelleValue), NULL);
    }

    if (FireRateStatus)
    {

        DWORD FireRateAddressToWrite = FindDmaAddy(1, hProcHandle, FireRateOffsets, FireRateBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)FireRateAddressToWrite, &FireRateValue, sizeof(FireRateValue), NULL);
    }

    if (MellePowerStatus)
    {

        DWORD MellePowerAddressToWrite = FindDmaAddy(1, hProcHandle, MellePowerOffsets, MellePowerBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)MellePowerAddressToWrite, &MellePowerValue, sizeof(MellePowerValue), NULL);
    }

    if (RiflePowerStatus)
    {

        DWORD RiflePowerAddressToWrite = FindDmaAddy(1, hProcHandle, RiflePowerOffsets, RiflePowerBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)RiflePowerAddressToWrite, &RiflePowerValue, sizeof(RiflePowerValue), NULL);
    }

    if (ShotgunPowerStatus)
    {

        DWORD ShotgunPowerAddressToWrite = FindDmaAddy(1, hProcHandle, ShotgunPowerOffsets, ShotgunPowerBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)ShotgunPowerAddressToWrite, &ShotgunPowerValue, sizeof(ShotgunPowerValue), NULL);
    }

    if (SniperPowerStatus)
    {

        DWORD SniperPowerAddressToWrite = FindDmaAddy(1, hProcHandle, SniperPowerOffsets, SniperPowerBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)SniperPowerAddressToWrite, &SniperPowerValue, sizeof(SniperPowerValue), NULL);
    }

    if (BossStatus)
    {

        DWORD BossAddressToWrite = FindDmaAddy(1, hProcHandle, BossOffsets, BossBaseAddress);
        WriteProcessMemory(hProcHandle, (int*)BossAddressToWrite, &BossValue, sizeof(BossValue), NULL);
    }

    if (SpeedStatus)
    {

        DWORD SpeedAddressToWrite = FindDmaAddy(1, hProcHandle, SpeedOffsets, SpeedBaseAddress);
        WriteProcessMemory(hProcHandle, (float*)SpeedAddressToWrite, &SpeedValue, sizeof(SpeedValue), NULL);
    }

    if (AutoCaptureStatus)
    {

        DWORD AutoCaptureAddressToWrite = FindDmaAddy(1, hProcHandle, AutoCaptureOffsets, AutoCaptureBaseAddress);
        WriteProcessMemory(hProcHandle, (float*)AutoCaptureAddressToWrite, &AutoCaptureValue, sizeof(AutoCaptureValue), NULL);
    }

    if (GravityStatus)
    {

        DWORD GravityAddressToWrite = FindDmaAddy(1, hProcHandle, GravityOffsets, GravityBaseAddress);
        WriteProcessMemory(hProcHandle, (float*)GravityAddressToWrite, &GravityPowerValue, sizeof(GravityValue), NULL);
    }

    if (AcuarityStatus)
    {

        DWORD AcuarityPowerAddressToWrite = FindDmaAddy(1, hProcHandle, AcuarityOffsets, AcuarityBaseAddress);
        WriteProcessMemory(hProcHandle, (double*)AcuarityAddressToWrite, &AcuarityValue, sizeof(AcuarityPowerValue), NULL);
    }

    {
    }
}

在Visual Studio（2013 btw）的底部，这个上架，

我没有使用其他任何东西，你能指出我的问题或以某种方式修复它吗？

Answer 1

包括#stdafx.h

尝试将LPCSTR转换为LPCWSTRS，尝试使用atlbase。这是一个简单的例子：

#include <Windows.h>
#include <atlbase.h>
#include <iostream>

int main(int argc, char *argv[]) {
    USES_CONVERSION;
    LPCSTR a = "hello";
    LPCWSTR w = A2W(a);
    std::wcout << w << std::endl;
    return 0;
}

VS13中的IntelliSense愚蠢错误

1 个答案: