Вопрос Bunnyhop not working

[deutscherpatriot88]

Hello guys, ive tried to update my internal but my aimbot and movement related things are not working.

void misc::c_movement::proccess_jump(CCSGOInput* a1, CBaseUserCmdPB* crc, CUserCmd* cmd)
{
    if (!cfg_get(bool, g_cfg.bunny_hop))
        return;

    if (!sdk::m_engine->connected() || !sdk::m_engine->in_game())
        return;

    if (!crc || !cmd || g::sv_autobunnyhopping)
        return;

    if (!crc->pInButtonState)
        return;
    /*
    if ((crc->pInButtonState->nValue & IN_JUMP) && g::m_local_player_pawn->m_fFlags() & FL_ONGROUND)
    {
        crc->pInButtonState->bit(BUTTON_STATE_PB_BITS_BUTTONSTATE1);
        crc->pInButtonState->nValueChanged &= ~IN_JUMP;
    }
    */
    auto player = g::m_local_player_pawn;
    if (!player)
        return;


    if (player->m_fFlags() & FL_ONGROUND)
    {
        crc->pInButtonState->bit(EButtonStatePBBits::BUTTON_STATE_PB_BITS_BUTTONSTATE1);
        crc->pInButtonState->nValue &= ~IN_JUMP;
    }
}

class CCSGOInput
{

public:
    char pad_0000[0x228]; //0x0000
    bool bBlockShot; //0x0250
    bool bInThirdPerson; //0x0251
    char pad_0252[6]; //0x0252
    QAngle_t angThirdPersonAngles; //0x0258
    char pad_0264[0x04]; //0x0264
    uint64_t nKeyboardPressed; //0x0278
    uint64_t nMouseWheelheelPressed; //0x0280
    uint64_t nUnPressed; //0x0288
    uint64_t nKeyboardCopy; //0x0290
    float flForwardMove; //0x0298
    float flSideMove; //0x029C
    float flUpMove; //0x02A0
    Vector2D_t nMousePos; //0x02A4
    int32_t SubticksCount; //0x02AC
    CTinyMoveStepData Subticks[12]; //0x02B0
    Vector_t vecViewAngle; //0x03D0
    int32_t nTargetHandle; //0x03DC
    char pad_03E0[560]; //0x03E0
    int32_t pad1; //0x0610
    int32_t pad12; //0x0614
    int32_t nAttackStartHistoryIndex1; //0x0618
    int32_t nAttackStartHistoryIndex2; //0x061c
    int32_t nAttackStartHistoryIndex3; //0x0620
    char pad_061C[4]; //0x061C
    int32_t MessageSize; //0x0620
    char pad_0624[4]; //0x0624
    CCSInputMessage* Message; //0x0628
public:
    bool push(uint64_t button, bool held, float when = 0.90f) {
        if (SubticksCount >= 12)
            return false;

        Subticks[SubticksCount++].flWhen = when;
        Subticks[SubticksCount++].nButton = button;
        Subticks[SubticksCount++].bPressed = held;

        return true;
    }

    uint8_t release(uint64_t button) {
        uint8_t c = 0;
        for (int i = 0; i < SubticksCount; i++) {
            if (Subticks[i].nButton == button) {
                memmove(Subticks + i, Subticks + i + 1, (SubticksCount - i - 1) * sizeof(CTinyMoveStepData));
                SubticksCount--;
                i--;
                c++;
            }
        }
        return c;
    }

    void add_button(ECommandButtons button);
    /*
    void remove_button(ECommandButtons button) {
        const auto button_state{ hooks::m_get_button_state(this, 0) };

        auto& buttonCount{ recast_at_pointer(int, button_state, 0x34) };

        auto v6{ recast_at_pointer(int, this, 0x54F8) };

        while ((int)v6 < buttonCount) {
            auto currentButton{ (BYTE*)(reinterpret_cast<std::uintptr_t>(button_state) + 24 * (3 + v6)) };

            auto& v15{ recast_at_pointer(__int64, currentButton, -8) };
            if (v15 & button)
                v15 = 0;

            ++v6;
        }
    }
    */
    QAngle_t get_view_angles()
    {
        using fnGetViewAngles = std::int64_t(CS_FASTCALL*)(CCSGOInput*, std::int32_t);
        static auto oGetViewAngles = reinterpret_cast<fnGetViewAngles>(utils::FindPattern(xorstr_("client.dll"), xorstr_("4C 8B C1 85 D2 74 08 48 8D 05 ? ? ? ? C3")));

        return *reinterpret_cast<QAngle_t*>(oGetViewAngles(this, 0));
    }
    void set_input_angle(QAngle_t& angView, bool client_side = false)
    {
        if (client_side)
            angView.z = 0.f;
        // @ida: this got called before GetMatricesForView
        using fnSetViewAngle = std::int64_t(__fastcall*)(void*, std::int32_t, QAngle_t&);
        static auto oSetViewAngle = reinterpret_cast<fnSetViewAngle>(utils::FindPattern("client.dll", ("85 D2 75 ? 48 63 81")));


        oSetViewAngle(this, 0, std::ref(angView));
    }
};

class CBaseUserCmdPB : public CBasePB
{
public:
    RepeatedPtrField_t<CSubtickMoveStep> subtickMovesField; // 0x18
    std::string* strMoveCrc;
    CInButtonStatePB* pInButtonState;
    CMsgQAngle* view_angles;
    std::int32_t nLegacyCommandNumber;
    std::int32_t nClientTick;
    float flForwardMove;
    float flSideMove;
    float flUpMove;
    std::int32_t nImpulse;
    std::int32_t nWeaponSelect;
    std::int32_t nRandomSeed;
    std::int32_t nMousedX;
    std::int32_t nMousedY;
    std::uint32_t nConsumedServerAngleChanges;
    std::int32_t nCmdFlags;
    std::uint32_t nPawnEntityHandle;
public:

    std::uint8_t get_crc_size() {
        return utils::CallVFunc<std::uint8_t, 7u>(this);
    }
    CSubtickMoveStep* create_new_subtick_step();
    void set_view_angles(QAngle_t angle) {
        if (!this)
            return;

        if (!view_angles)
            return;

        bit(BASE_BITS_VIEWANGLES);
        view_angles->bit(BASE_BITS_VIEWANGLES);
        view_angles->angValue = angle;
    }
    void set_tick_count(int tick) {
        if (!this)
            return;

        /* set current client tick */
        bit(BASE_BITS_CLIENT_TICK);
        nClientTick = tick;
    }
    void attack() {
        if (!this)
            return;

        // set the IN_ATTACK flag to simulate the shot
        this->bit(EButtonStatePBBits::BUTTON_STATE_PB_BITS_BUTTONSTATE1);
        this->pInButtonState->nValue |= IN_ATTACK;
        this->bit(EButtonStatePBBits::BUTTON_STATE_PB_BITS_BUTTONSTATE2);
        this->pInButtonState->nValueChanged |= IN_ATTACK;
    }

    void update_button() {
        if (!this)
            return;

        this->bit(EButtonStatePBBits::BUTTON_STATE_PB_BITS_BUTTONSTATE1);
        this->pInButtonState->nValue |= IN_ATTACK;
    }

    void invalidate_pitch() {
        if (!this || !this->view_angles)
            return;

        this->bit(CachedBits::BASE_BITS_VIEWANGLES);
        this->view_angles->angValue.x = 179.f;
    }
};
static_assert(sizeof(CBaseUserCmdPB) == 0x80);

class CUserCmd
{
public:
    pad(0x8); // 0x0 VTABLE
    pad(0x10); // TODO: find out what this is, added 14.08.2024
    std::uint32_t nHasBits;
    std::uint64_t nCachedSize;
    RepeatedPtrField_t<CCSGOInputHistoryEntryPB> inputHistoryField;
    CBaseUserCmdPB* pBaseCmd;
    bool m_bLeftHandDesired;
    bool m_bIsPredictingBodyShotFX;
    bool m_bIsPredictingHeadShotFX;
    bool m_bIsPredictingKillRagdolls;
    std::int32_t nAttack1StartHistoryIndex; //"0x50" for ida
    std::int32_t nAttack2StartHistoryIndex;
    CInButtonState nButtons; // 0x58
    pad(0x10);
    bool bHasBeenPredicted;
    pad(0xF);
public:
    bool CRC(CBaseUserCmdPB* m_base);
    void bit(std::uint32_t nBits)
    {
        if (!(nHasBits & nBits))
            nHasBits |= nBits;
    }
    CSubtickMoveStep* create_subtick_step(void* arena);
    CSubtickMoveStep* create_subtick();

    CSubtickMoveStep* get_move_step(int nIndex)
    {
        if (nIndex >= pBaseCmd->subtickMovesField.pRep->nAllocatedSize || nIndex >= pBaseCmd->subtickMovesField.nCurrentSize)
            return nullptr;

        return pBaseCmd->subtickMovesField.pRep->tElements[nIndex];
    }

    CCSGOInputHistoryEntryPB* get_input_history_tick(int nIndex)
    {
        if (nIndex >= inputHistoryField.pRep->nAllocatedSize || nIndex >= inputHistoryField.nCurrentSize)
            return nullptr;

        return inputHistoryField.pRep->tElements[nIndex];
    }

    void set_sub_tick_angle(const QAngle_t& angView)
    {
        for (int i = 0; i < this->inputHistoryField.pRep->nAllocatedSize; i++) {
            auto sub_tick = this->get_input_history_tick(i);
            if (!sub_tick)
                continue;

            if (!sub_tick->pViewAngles)
                continue;

            sub_tick->bit(EInputHistoryBits::INPUT_HISTORY_BITS_VIEWANGLES);
            sub_tick->pViewAngles->angValue = angView;
            sub_tick->pViewAngles->angValue.Clamp();
        }
    }

    QAngle_t get_view_angle() {

        if (!this)
            return QAngle_t(0, 0, 0);

        if (!this->pBaseCmd)
            return QAngle_t(0, 0, 0);

        if (!this->pBaseCmd->view_angles)
            return QAngle_t(0, 0, 0);

        return this->pBaseCmd->view_angles->angValue;
    }


    void add_step_sub_tick(bool pressed, int button, float fraction = 1.f) {
        if (!this)
            return;

        auto correct_subtick_move_step = this->create_subtick();
        if (!correct_subtick_move_step)
            return;

        auto base_cmd = this->pBaseCmd;
        if (!base_cmd)
            return;

        auto cur_sub_tick = base_cmd->subtickMovesField.pRep;
        if (!cur_sub_tick)
            return;

        auto v46 = correct_subtick_move_step->nCachedBits | 4;
        correct_subtick_move_step->nCachedBits = v46;

        if (pressed)
            correct_subtick_move_step->flWhen = fraction;

        auto v48 = v46 | 1;
        correct_subtick_move_step->nCachedBits = v48;
        correct_subtick_move_step->nButton = button;

        correct_subtick_move_step->nCachedBits = v48 | 2;
        correct_subtick_move_step->bPressed = pressed;

    }

    void filter_sub_tick(int button) {
        if (!this)
            return;

        auto base_cmd = this->pBaseCmd;
        if (!base_cmd)
            return;

        auto cur_sub_tick = base_cmd->subtickMovesField.pRep;
        if (!cur_sub_tick)
            return;

        for (int i{ }; i < base_cmd->subtickMovesField.nCurrentSize; i++) {
            auto step_move = base_cmd->subtickMovesField.pRep->tElements[i];

            if (!step_move || step_move->nButton != button)
                continue;

            auto v46 = step_move->nCachedBits | 4;
            auto v48 = v46 | 1;

            step_move->nCachedBits = v48;
            step_move->nButton = 0;

        }
    }

    static CBaseUserCmdPB* GetBase();
    static CUserCmd* Get();


};

 

[whoise80]

з

 

[Frrreak]

ты бхоп на юзерцмд теперь не сделаешь теперь как мне сказали

Хрень полная

 

[ayi]

ты бхоп на юзерцмд теперь не сделаешь теперь как мне сказали

 

[deutscherpatriot88]

How would I do it then?

 

[oktellmepls]

Больные , лечитесь

 

[Ped0lk]

 

[deutscherpatriot88]

i dont really know what am i doing wrong cuz this is not working

void misc::c_movement::proccess_jump(CCSGOInput* a1, CUserCmd* cmd)
{
    if (!cfg_get(bool, g_cfg.bunny_hop))
        return;

    if (!sdk::m_engine->connected() || !sdk::m_engine->in_game())
        return;

    if (!cmd || g::sv_autobunnyhopping)
        return;

    auto player = g::m_local_player_pawn;
    if (!player)
        return;


    if (player->m_fFlags() & FL_ONGROUND)
    {
        cmd->nButtons.nValue &= ~IN_JUMP;
    }
}