Куплю Куплю resolver

_spokyvac_ · 22 Мар 2022

Куплю ресольвер. База любая кроме вива (да, без лишних вопросов).
Цена: 500-600р.
telegram @senseseller

wexed · 22 Мар 2022

Мне кажется вряд ли получится найти годный рес с таким маленьким бюджетом
Скорее всего вырежут из какой нибудь слитой пасты лв и скажут что $elf-co0de3

cazzual · 22 Мар 2022

wexed написал(а):
Мне кажется вряд ли получится найти годный рес с таким маленьким бюджетом
Скорее всего вырежут из какой нибудь слитой пасты лв и скажут что $elf-co0de3

Никто не отменял цена=качество. Может человеку нужно именно под эту цену что-то средненькое ¯\_(ツ)_/¯

Mishaal · 22 Мар 2022

Скорее всего тебя наебут, взяв старый резик и переписав пару строчек кода. Лучше сам ищи что-то годное в паблике, объединяй, проси советов, используй найденную информацию себе во благо. Интернет огромен, мб что-то найдешь

Homia4iX1337 · 22 Мар 2022

C++:

Resolver g_resolver{};

void Resolver::SetMode(LagComp::LagRecord_t* record)
{
    // the resolver has 4 modes to chose from.
    // these modes will vary more under the hood depending on what data we have about the player.
    if (record->m_bIsFakePlayer) {
        record->m_iResolveMode = Modes::RESOLVE_NONE;
        return;
    }

    // if not on ground.
    if (!(record->m_fFlags & FL_ONGROUND))
        record->m_iResolveMode = Modes::RESOLVE_AIR;

    // if sideways.
    else if (record->m_bIsLeft || record->m_bIsRight)
        record->m_iResolveMode = Modes::RESOLVE_SIDEWAYS;

    // if on ground and fast moving.
    else if (record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_weight > 0.7f)
        record->m_iResolveMode = Modes::RESOLVE_RUN;

    // if on ground and moving.
    else if (record->m_vecVelocity.length_2d() > 0.1f)
        record->m_iResolveMode = Modes::RESOLVE_WALK;

    // if on ground and not moving.
    else
        record->m_iResolveMode = Modes::RESOLVE_STAND;
}

void Resolver::ResolveAngles(Player* player, LagComp::LagRecord_t* record, LagComp::LagRecord_t* previous_record) {
    AimPlayer* data = &g_aimbot.m_players[player->index() - 1];

    // next up mark this record with a resolver mode that will be used.
    SetMode(record);

    // restore some data.
    data->m_type = 0;
    data->m_side = 0;
    data->m_resolve_strenght = 10.f;

    if (record->m_bIsFakePlayer || !g_menu.main.aimbot.correct.get()) {
        record->m_flResolveStrengh = data->m_resolve_strenght = 0.f;
        record->m_iResolveSide = data->m_side;
        player->m_PlayerAnimState()->m_flFootYaw = math::NormalizedAngle(record->m_angEyeAngles.y);
        return;
    }

    if (!record->m_bDidShot) {
        if (!data->m_missed_shots) {
            if (record->m_iResolveMode != Modes::RESOLVE_STAND) {
                if (record->m_iResolveMode != Modes::RESOLVE_RUN) {
                    if (record->m_iResolveMode != Modes::RESOLVE_SIDEWAYS) {
                        if (record->m_iResolveMode != Modes::RESOLVE_AIR)
                        {
                            // default.
                            data->m_type = data->m_type_before_bruteforce = 1;
                            data->m_side_before_bruteforce = -1;
                        }
                        else
                        {
                            // default.
                            data->m_type = data->m_type_before_bruteforce = 2;
                            data->m_side_before_bruteforce = -1;
                        }
                    }
                    else
                    {
                        // default.
                        data->m_type = data->m_type_before_bruteforce = 3;
                        data->m_side_before_bruteforce = -1;
                    }
                }
                else
                {
                    // default.
                    data->m_type = data->m_type_before_bruteforce = 4;
                    data->m_side_before_bruteforce = -1;
                }               

                // delta.
                if (record->m_iResolveMode != Modes::RESOLVE_SIDEWAYS && record->m_iResolveMode != Modes::RESOLVE_AIR && fabsf(record->m_flLeftDelta - record->m_flRightDelta) > 15.f) {
                    if (record->m_flLeftDelta > record->m_flRightDelta) {
                        data->m_type = data->m_type_before_bruteforce = 5;
                        data->m_side = data->m_side_before_bruteforce = -1;
                        data->m_resolve_strenght = 60.f;
                    }
                    else {
                        data->m_type = data->m_type_before_bruteforce = 5;
                        data->m_side = data->m_side_before_bruteforce = 1;
                        data->m_resolve_strenght = 60.f;
                    }
                }

                // animlayers.
                if (previous_record) {
                    float delta_positive = fabsf(record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate - record->m_pPositiveLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate);
                    float delta_negative = fabsf(record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate - record->m_pNegativeLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate);
                    float delta_zero = fabsf(record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate - record->m_pZeroLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_playback_rate);

                    if (int(record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_weight * 1000.f) == int(previous_record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_weight * 1000.f))
                    {
                        if (!int(record->m_pLayers[ANIMATION_LAYER_LEAN].m_weight * 1000.f))
                        {                           
                            // onetap.
                            if (delta_zero < delta_positive || delta_negative <= delta_positive || (delta_positive * 1000.f)) {
                                if (delta_zero >= delta_negative && delta_positive > delta_negative && !(delta_negative * 1000.f)) {
                                    data->m_type = data->m_type_before_bruteforce = 6;
                                    data->m_side_before_bruteforce = 1;
                                    data->m_resolve_strenght = 60.f;
                                }
                            }
                            else {
                                data->m_type = data->m_type_before_bruteforce = 6;
                                data->m_side_before_bruteforce = -1;
                                data->m_resolve_strenght = 60.f;
                            }
                        }

                        // nemesis.
                        if (delta_positive <= delta_zero)
                            record->m_flMoveDelta = delta_positive;
                        else
                            record->m_flMoveDelta = delta_zero;

                        if (record->m_flMoveDelta > delta_negative)
                            record->m_flMoveDelta = delta_negative;                       

                        if (!(record->m_flMoveDelta * 1000.f) && (delta_zero * 10000.f) != (delta_negative * 10000.f) && (record->m_flMoveDelta * 10000.f) != (delta_positive * 10000.f)) {
                            if (record->m_flMoveDelta == delta_negative) {
                                data->m_type = data->m_type_before_bruteforce = 7;
                                data->m_side_before_bruteforce = -1;
                                data->m_resolve_strenght = 60.f;
                            }
                            else if (record->m_flMoveDelta == delta_zero) {
                                data->m_type = data->m_type_before_bruteforce = 7;
                                data->m_side_before_bruteforce = 1;
                                data->m_resolve_strenght = 60.f;
                            }
                        }
                    }
                }
            }
            else
            {
                // default.
                data->m_type = data->m_type_before_bruteforce = 8;
                data->m_side_before_bruteforce = 1;
                data->m_resolve_strenght = 60.f;

                // delta.
                if (record->m_pLayers[ANIMATION_LAYER_ADJUST].m_weight == 0.f && record->m_pLayers[ANIMATION_LAYER_ADJUST].m_cycle == 0.f && record->m_pLayers[ANIMATION_LAYER_MOVEMENT_MOVE].m_weight == 0.f) {
                    data->m_type = data->m_type_before_bruteforce = 9;
                    data->m_side_before_bruteforce = 2 * int(math::AngleDiff(record->m_angEyeAngles.y, record->m_flOriginalGoalFeetYaw) <= 0.f) - 1;
                    data->m_resolve_strenght = 60.f;
                }
            }
        }
        else
            data->m_type = 10;
                
        if (record->m_iResolveMode == Modes::RESOLVE_RUN || record->m_iResolveMode == Modes::RESOLVE_AIR) {
            if (data->m_type_before_bruteforce == 5 || data->m_type_before_bruteforce == 6 || data->m_type_before_bruteforce == 9) {
                switch (data->m_missed_shots % 2) {
                case 0:
                    data->m_side = data->m_side_before_bruteforce;
                    break;
                case 1:
                    data->m_side = -1;
                    data->m_resolve_strenght = 10.f;
                    break;
                }
            }
            else {
                switch (data->m_missed_shots % 5) {
                case 0:
                    data->m_side = data->m_side_before_bruteforce;
                    break;
                case 1:
                    data->m_side = -data->m_side_before_bruteforce;
                    data->m_resolve_strenght = 30.f;
                    break;
                case 2:
                    data->m_side = data->m_side_before_bruteforce;
                    data->m_resolve_strenght = 30.f;
                    break;
                case 3:
                    data->m_side = data->m_side_before_bruteforce;
                    data->m_resolve_strenght = 60.f;
                    break;
                case 4:
                    data->m_side = -data->m_side_before_bruteforce;
                    data->m_resolve_strenght = 60.f;
                    break;
                }
            }
        }
        else if (data->m_type_before_bruteforce == 9) {
            switch (data->m_missed_shots % 3) {
            case 0:
                data->m_side = data->m_side_before_bruteforce;
                break;
            case 1:
                data->m_side = -data->m_side_before_bruteforce;
                data->m_resolve_strenght = 60.f;
                break;
            case 2:
                data->m_side = -1;
                data->m_resolve_strenght = 10.f;
                break;
            }
        }
        else {
            switch (data->m_missed_shots % 5) {
            case 0:
                data->m_side = data->m_side_before_bruteforce;
                break;
            case 1:
                data->m_side = -data->m_side_before_bruteforce;
                data->m_resolve_strenght = 60.f;
                break;
            case 2:
                data->m_side = data->m_side_before_bruteforce;
                data->m_resolve_strenght = 60.f;
                break;
            case 3:
                data->m_side = data->m_side_before_bruteforce;
                data->m_resolve_strenght = 30.f;
                break;
            case 4:
                data->m_side = -data->m_side_before_bruteforce;
                data->m_resolve_strenght = 30.f;
                break;
            }
        }
    }
    else
    {
        data->m_type = 11;
        data->m_side = -1;

        //float flPseudoFireYaw = math::NormalizedAngle(math::CalcAngle(record->m_pMatrix[8].GetOrigin(), g_cl.m_local->m_BoneCache().m_pCachedBones[0].GetOrigin()).y);

        //if (record->m_pLayers[3].m_cycle == 0.f && record->m_pLayers[3].m_weight == 0.f) {
        //    float flLeftFireYawDelta = fabsf(math::NormalizedAngle(flPseudoFireYaw - (record->m_angEyeAngles.y + 56.f)));
        //    float flRightFireYawDelta = fabsf(math::NormalizedAngle(flPseudoFireYaw - (record->m_angEyeAngles.y - 56.f)));

        //    data->m_type = 12;
        //    data->m_side = flLeftFireYawDelta > flRightFireYawDelta ? -1 : 1;
        //    data->m_resolve_strenght = 56.f;
        //}
        //else {
        //    float flLeftFireYawDelta = fabsf(math::NormalizedAngle(flPseudoFireYaw - (record->m_angEyeAngles.y + 35.f)));
        //    float flRightFireYawDelta = fabsf(math::NormalizedAngle(flPseudoFireYaw - (record->m_angEyeAngles.y - 35.f)));

        //    data->m_type = 13;
        //    data->m_side = flLeftFireYawDelta > flRightFireYawDelta ? -1 : 1;
        //    data->m_resolve_strenght = 35.f;
        //}
    }

    record->m_flResolveStrengh = data->m_resolve_strenght;
    record->m_iResolveSide = data->m_side;

    player->m_PlayerAnimState()->m_flFootYaw = math::NormalizedAngle(record->m_angEyeAngles.y + (data->m_side * data->m_resolve_strenght));
}

superior resolver$$$$$$$$$$$$$$$