Информация Полезные функции

float getFloatFromMemory(unsigned char* memoryAddress) {
    float* floatPtr = reinterpret_cast<float*>(memoryAddress);
    return *floatPtr;
}
void setFloatToMemory(unsigned char* memoryAddress, float value) {
    float* floatPtr = reinterpret_cast<float*>(memoryAddress);
    *floatPtr = value * 31.47000244;
}

    unsigned char* memoryAddress = reinterpret_cast<unsigned char*>(0xB7CDB4);

    float value = 0.0f;

    if (type >= 20) value = 100.0f;
    else if (type >= 10 && type <= 19) value = 0.0f;
    else if (type >= 4 && type <= 9) value = -10.0f;
    else value = -100.0f;

    setFloatToMemory(memoryAddress, value);
    float floatValue = getFloatFromMemory(memoryAddress);

for (CPed* pPed : CPools::ms_pPedPool)
{
    short id = SAMP::Pools::Player::Find(pPed);
    if (id == -1)
        continue;
}

short SAMP::Pools::Player::Find(CPed* pPed)
{
    // pPlayer PlayerPool
    // Pools + 0x8   DL
    // Pools + 0x18 R1
    // Pools + 0x8   R2
    // Pools + 0x8   R3
    // Pools + 0x8   R4
    // Pools + 0x4   R5

    if (!m_pPlayer || !pPed)
        return -1;

    static const std::uintptr_t uiOffsets[] =
    {
       0x137C0, // DL
       0x10420, // R1
       0x104C0, // R2
       0x13570, // R3
       0x13890, // R4
       0x138C0  // R5
    };

    return reinterpret_cast<short(__thiscall*)(void*, CPed*)>(GetModule() + uiOffsets[GetVersion()])(pPlayer, pPed);
}

// дефолтное значение 0.1000000015. длина прыжка с места
plugin::patch::SetFloat(0x8703B0, 0.1000000015f * fRangeValue);

// дефолтное значение 0.1700000018. длина прыжка с бега
plugin::patch::SetFloat(0x8703B4, 0.1700000018f * fRangeValue);

// дефолтное значение 0.2199999988. длина прыжка со спринта
plugin::patch::SetFloat(0x8703B8, 0.2199999988f * fRangeValue);

// дефолтное значение 8.5. высота прыжка
plugin::patch::SetFloat(0x8703C0, 8.5f * fHeightValue);

#include <string>
#include <random>
#include <algorithm>
#include <cstdio>

#if defined(_WIN32)
    #include <intrin.h>
#endif

std::string generateString()
{
    static const unsigned char num_char[] =
    {
        0x4A,0x4B,0x4C,0x4D,0x4E,0x4F,0x5A,0x5B,0x5C,0x5D,0x5E,0x5F,
        0x6A,0x6B,0x6C,0x6D,0x6E,0x6F,0x3F,0x8D,0x9A,0x9C,0x9D,0x9F,0x7C,0x7A
    };
    static const unsigned char char_num[] =
    {
        0xC0,0xC1,0xC2,0xC3,0xC4,0xC5,0xC6,0xC7,0xC8,0xC9,0xD0,0xD1,
        0xD2,0xD3,0xD4,0xD6,0xD6,0xD7,0xD8,0xD9,0xE0,0xE1,0xE2,0xE3,
        0xE4,0xE5,0xE6,0xE7,0xE8,0xE9,0xF0,0xF1,0xF2,0xF3,0xF4,0xF5,
        0xF6,0xF7,0xF8,0xF9
    };
    std::random_device rd;
    std::mt19937 gen(rd());
    std::string result;
    for (int i = 0; i < 11; ++i) result += num_char[std::uniform_int_distribution<>(0, sizeof(num_char)-1)(gen)];
    for (int i = 0; i < 12; ++i) result += char_num[std::uniform_int_distribution<>(0, sizeof(char_num)-1)(gen)];
    std::shuffle(result.begin(), result.end(), gen);
    return result;
}

#if defined(_WIN32)
    #define byte_swap _byteswap_ulong
#else
    #define byte_swap __builtin_bswap32
#endif

std::string GenerateGPCI()
{
    std::string h = generateString();
    unsigned int s[5]{}, r[6]{}, i = 0;
    char b[49], *p = b;
    for (; i < 5; ++i) s[i] = byte_swap(*(unsigned int*)(h.data() + i*4));
    for (i = 0; i < 5; ++i) {
        unsigned long long t = 1001ULL * s[i] + r[i];
        r[i] = (unsigned int)t;
        r[i+1] = t >> 32;
    }
    for (i = 6; i--;) p += std::sprintf(p, "%08X", r[i]);
    for (p = b; *p == '0' && p[1]; ++p);
    return p;
}

#pragma GCC push_options
#pragma GCC optimize ("O0")
// code
#pragma GCC pop_options

#pragma optimize("", off)
// code
#pragma optimize("", on)