Исходник Better pre_cache_centers (a.k.a select records) for airflow v1.5

[veinedhvhs]

Hi everyone,

Пожалуйста, авторизуйтесь для просмотра ссылки.

. (noad) Here's a gift!
​

void pre_cache_centers(int damage, std::vector<int>& hitboxes, vec3_t& predicted_eye_pos, rage_player_t* rage)
{
    rage->reset_hitscan();

    auto anims = ANIMFIX->get_local_anims();
    auto lagcomp = ANIMFIX->get_anims(rage->player->index());
    if (!lagcomp || lagcomp->records.empty())
        return;

    auto netchannel = HACKS->engine->get_net_channel();
    if (!netchannel)
        return;

    bool extended_track = g_cfg.rage.extended_track;

    auto get_overall_damage = [&](anim_record_t* record) -> int
        {
            rage->points_to_scan.clear();
            rage->points_to_scan.reserve(MAX_SCANNED_POINTS);

            auto points = get_hitbox_points(damage, hitboxes, predicted_eye_pos, predicted_eye_pos, rage, record, true);
            if (points.empty()) 
                points = get_hitbox_points(damage, hitboxes, anims->eye_pos, predicted_eye_pos, rage, record, false);

            int overall_damage = 0;
            for (const auto& point : points) 
            {
                //bool safe_headshot = RAGEBOT->rage_config.body_aim_conditions & safe_point_headshot;
                //if (safe_headshot && point.hitbox != HITBOX_HEAD)
                //    continue;

                rage->points_to_scan.emplace_back(point);
                overall_damage += point.damage;
            }

            return overall_damage;
        };

    anim_record_t* best = nullptr;
    anim_record_t* best_candidate = nullptr;
    anim_record_t* valid_record = nullptr;

    rage->restore.store(rage->player);

    if (!HACKS->cl_lagcomp)
    {
        if (extended_track && lagcomp->records.size() > 1)
        {
            int max_damage = 0;

            for (auto& record : lagcomp->records)
            {
                if (record.valid_lc)
                {
                    int record_damage = get_overall_damage(&record);
                    if (record_damage > max_damage)
                    {
                        max_damage = record_damage;
                        best_candidate = &record;
                    }
                }
            }

            if (best_candidate && max_damage >= damage)
                best = best_candidate;
        }

        anim_record_t* extrapolated_record = &lagcomp->records.back();
        if (extrapolation(rage->player, lagcomp) && extrapolated_record && get_overall_damage(extrapolated_record) >= damage)
            best = extrapolated_record;
        else 
        {
            auto first_valid = std::find_if(lagcomp->records.begin(), lagcomp->records.end(), [&](anim_record_t& record) {
                return record.valid_lc && get_overall_damage(&record) >= damage;
                });

            if (first_valid != lagcomp->records.end())
                best = &(*first_valid);
        }
    }
    else
    {
        auto last_find = std::find_if(lagcomp->records.rbegin(), lagcomp->records.rend(), [&](anim_record_t& record) {
            return record.valid_lc && get_overall_damage(&record) >= damage;
            });

        if (last_find != lagcomp->records.rend())
            best = &*last_find;
    }

    rage->restore.restore(rage->player);

    if (best)
    {
        rage->start_scans = true;
        rage->hitscan_record = best;
    }
}

​

 

[zDrip]

useless

 

[shialex]

omfg

 

[ValveBAN88]

Why

 

[xaviersalvo]

worseflow