Исходник Nemesis Resolver // supremacy c+p ready

[mercury997]

void Resolver::NemsisResolver(Player* player, LagRecord* record, LagRecord* prev_record, resolver_data_t& data) {
    record->m_type = LAYERS;

    const auto& cur_layer6_weight = record->m_layers[6].m_weight;
    if (cur_layer6_weight <= 0.0099999998) {
        if (std::abs(math::AngleDiff(record->m_eye_angles.y, prev_record->m_eye_angles.y)) > 35.f)
            detect_side(player, record, data);

        return;
    }
    bool m_accelerating;
    const auto& cur_layer11_weight = record->m_layers[11].m_weight;
    const auto cur_layer12_weight = static_cast<int>(record->m_layers[12].m_weight * 1000.f);

    const auto cur_layer11_weight_valid = cur_layer11_weight > 0.f && cur_layer11_weight < 1.f;
    const auto prev_layer11_weight_valid = prev_record->m_layers[11].m_weight > 0.f && prev_record->m_layers[11].m_weight < 1.f;

    const auto prev_layer6_weight = static_cast<int>(prev_record->m_layers[6].m_weight * 1000.f);

    bool not_to_diff_vel_angle{};
    if (prev_record->m_layers[6].m_weight > 0.0099999998)
        not_to_diff_vel_angle = std::abs(
            math::AngleDiff(
                math::rad_to_deg(std::atan2(record->m_velocity.y, record->m_velocity.x)),
                math::rad_to_deg(std::atan2(prev_record->m_velocity.y, prev_record->m_velocity.x))
            )
        ) < 10.f;

    const auto not_accelerating = static_cast<int>(cur_layer6_weight * 1000.f) == prev_layer6_weight && !cur_layer12_weight;
    const auto v74 = cur_layer11_weight_valid && (!cur_layer12_weight || (prev_layer11_weight_valid && not_to_diff_vel_angle));

    if (!not_accelerating
        && !cur_layer11_weight_valid) {
        m_accelerating = false;

        goto ANOTHER_CHECK;
    }

    m_accelerating = true;

    if (!not_accelerating) {
    ANOTHER_CHECK:
        if (!v74) {
            if (std::abs(math::AngleDiff(record->m_eye_angles.y, prev_record->m_eye_angles.y)) > 35.f)
                detect_side(player, record, data);

            return;
        }
    }


    const auto& cur_layer6 = record->m_layers[6];

    const auto delta1 = std::abs(cur_layer6.m_playback_rate - record->m_resolver_layers[1][6].m_playback_rate);
    const auto delta2 = std::abs(cur_layer6.m_playback_rate - record->m_resolver_layers[2][6].m_playback_rate);

    if (static_cast<int>(delta1 * 10000.f) == static_cast<int>(delta2 * 10000.f)) {
        if (std::abs(math::AngleDiff(record->m_eye_angles.y, prev_record->m_eye_angles.y)) > 35.f)
            detect_side(player, record, data);
        return;
    }

    const auto delta0 = std::abs(cur_layer6.m_playback_rate - record->m_resolver_layers[0][6].m_playback_rate);

    float best_delta{};

    if (delta0 <= delta1)
        best_delta = delta0;
    else
        best_delta = delta1;

    if (best_delta > delta2)
        best_delta = delta2;

    if (static_cast<int>(best_delta * 1000.f)
        || static_cast<int>(best_delta * 10000.f) == static_cast<int>(delta0 * 10000.f)) {
        if (std::abs(math::AngleDiff(record->m_eye_angles.y, prev_record->m_eye_angles.y)) > 35.f)
            detect_side(player, record, data);

        return;
    }

    if (best_delta == delta2) {

        record->m_anim_side = RIGHT;

        return;
    }

    if (best_delta != delta1) {
        if (std::abs(math::AngleDiff(record->m_eye_angles.y, prev_record->m_eye_angles.y)) > 35.f)
            detect_side(player, record, data);

        return;
    }

    record->m_anim_side = LEFT;

}

float get_backward_side(Player* player) {
    return math::calculate_angle(g_cl.m_local->m_vecOrigin(), player->m_vecOrigin()).y;
}

void Resolver::detect_side(Player* player, LagRecord* record, resolver_data_t& data) {
    record->m_type = ENGINE;
    /* externs */
    vec3_t src3D, dst3D, forward, right, up, src, dst;
    float back_two, right_two, left_two;
    CGameTrace tr;
    CTraceFilter filter;

    /* angle vectors */
    math::AngleVectors(ang_t(0, get_backward_side(player), 0), &forward, &right, &up);

    /* filtering */
    filter.pSkip = player;
    src3D = player->GetEyePosition();
    dst3D = src3D + (forward * 384);

    /* back engine tracers */
    m_engine_trace->trace_ray(Ray(src3D, dst3D), MASK_SHOT, &filter, &tr);
    back_two = (tr.m_endpos - tr.m_startpos).length();

    /* right engine tracers */
    m_engine_trace->trace_ray(Ray(src3D + right * 35, dst3D + right * 35), MASK_SHOT, &filter, &tr);
    right_two = (tr.m_endpos - tr.m_startpos).length();

    /* left engine tracers */
    m_engine_trace->trace_ray(Ray(src3D - right * 35, dst3D - right * 35), MASK_SHOT, &filter, &tr);
    left_two = (tr.m_endpos - tr.m_startpos).length();

    /* fix side */
    if (left_two > right_two) {
        record->m_anim_side = LEFT;
    }
    else if (right_two > left_two) {
        record->m_anim_side = RIGHT;
    }
    else
        get_side_trace(player, record, data);
}

void Resolver::get_side_trace(Player* player, LagRecord* record, resolver_data_t& data) {
    // get lag compensation data.
    AimPlayer* lag_data = g_lagcomp.GetLagData(player->m_entIndex);
    if (!lag_data || lag_data->m_records.size() < 2)
        return;

    auto m_side = false;
    auto trace = false;
    if (m_global_vars->m_curtime - data.m_lock_side > 2.0f) {
        auto first_visible = player->visible(player->GetEyePosition(), player->hitbox_position_matrix(HITBOX_HEAD, record->m_matrix[1]), player, g_cl.m_local);
        auto second_visible = player->visible(player->GetEyePosition(), player->hitbox_position_matrix(HITBOX_HEAD, record->m_matrix[2]), player, g_cl.m_local);

        if (first_visible != second_visible) {
            trace = true;
            m_side = second_visible;
            data.m_lock_side = m_global_vars->m_curtime;
        }
        else {
            auto first_position = player->GetEyePosition().dist_to(player->hitbox_position_matrix(HITBOX_HEAD, record->m_matrix[1]));
            auto second_position = player->GetEyePosition().dist_to(player->hitbox_position_matrix(HITBOX_HEAD, record->m_matrix[2]));

            if (fabs(first_position - second_position) > 1.0f)
                m_side = first_position > second_position;
        }
    }
    else
        trace = true;

    if (m_side) {
        record->m_type = trace ? TRACE : DIRECTIONAL;
        record->m_anim_side = RIGHT;
    }
    else {
        record->m_type = trace ? TRACE : DIRECTIONAL;
        record->m_anim_side = LEFT;
    }
}

 

[BURG1337]

/del

 

[veinedhvhs]

2020... перестаньте копипастить разработки лламы