Welcome to HvH Forum!

DestroyLonely · 6/17/25

hello guys this is a strong 2018 resolver, best on this site..
enjoy this

resolver:

static float pred_foot_delta(const std::deque<std::shared_ptr<lag_record>>& records) {  // delay updates will suffer instantly
    if (records.size() < 3)
        return 0.0f;

    std::vector<float> deltas;
    deltas.reserve(records.size() - 1);

    for (size_t i = 1; i < records.size(); ++i) {
        const auto& prev = records[i - 1];
        const auto& curr = records[i];

        float delta = math::normalized_angle(curr->m_body - prev->m_body);
        deltas.push_back(delta);
    }

    float avg_delta = std::accumulate(deltas.begin(), deltas.end(), 0.0f) / deltas.size();
    float max_abs_delta = 0.0f;
    float sign = 1.0f;

    for (float d : deltas) {
        if (fabsf(d) > fabsf(max_abs_delta)) {
            max_abs_delta = d;
            sign = (d >= 0.f) ? 1.f : -1.f;
        }
    }

    if (fabsf(max_abs_delta) > 35.0f) {
        return -sign * 60.0f;
    }

    return 0.0f;
}

float curvature_heuristic(const std::deque<std::shared_ptr<lag_record>>& records) {
    if (records.size() < 4)
        return 0.0f;

    std::vector<float> velocity;
    for (size_t i = 1; i < records.size(); ++i) {
        const float dyaw = math::angle_diff(records[i]->m_body, records[i - 1]->m_body);
        const float dt = records[i]->m_anim_time - records[i - 1]->m_anim_time;
        velocity.push_back(dt > 0.0f ? dyaw / dt : 0.0f);
    }

    float curvature = 0.0f;
    for (size_t i = 1; i < velocity.size(); ++i)
        curvature += velocity[i] - velocity[i - 1];

    return curvature; // free headshots bro, but u need good anims
}

float resolver::calculate_stand(aim_player* data, lag_record* record, const lag_record* prev, csgo_player_anim_state* state) { // why u might ask? it works, hs if good
    if (!data || !record || !prev)
        return record ? record->m_body : 0.0f;

    const auto& adjust = record->m_layers[animation_layer_adjust];
    const auto& prev_adjust = prev->m_layers[animation_layer_adjust];
    const float anim_dt = record->m_anim_time - prev->m_anim_time;

    if (adjust.m_n_sequence == 979 || adjust.m_n_sequence == 978) {
        const bool cycle_reset = prev_adjust.m_fl_cycle > 0.8f && adjust.m_fl_cycle < 0.2f;
        const bool weight_spike = (adjust.m_fl_weight - prev_adjust.m_fl_weight > 0.45f) && (adjust.m_fl_weight > 0.9f);

        if (cycle_reset && weight_spike) {
            return record->m_body;
        }
    }

    if (data->m_records.size() >= 4) {
        float curvature = curvature_heuristic(data->m_records);
        if (fabsf(curvature) > 35.0f) {
            return math::normalized_angle(record->m_body + curvature);
        }
    }

    if (adjust.m_fl_weight < 0.01f && fabsf(adjust.m_fl_cycle - prev_adjust.m_fl_cycle) < 0.001f) {
        return math::normalized_angle(record->m_body + 180.0f); // yes, lol.
    }

    if (data->m_records.size() >= 3) {
        const float pred_offset = pred_foot_delta(data->m_records);
        return math::normalized_angle(record->m_body + pred_offset);
    }

    const float max_desync = state->m_fl_aim_yaw_max; // valve is retarded for this but its working
    const float body_delta = math::angle_diff(record->m_body, prev->m_body);

    const bool clamp_l = body_delta < -max_desync + 0.1f;
    const bool clamp_r = body_delta > max_desync - 0.1f;

    if (clamp_l || clamp_r) {
        const float invert = clamp_l ? -max_desync : max_desync;
        return math::normalized_angle(record->m_body + invert);
    }

    const int act = record->m_layers[6].m_n_sequence;
    if (act == act_csgo_idle_turn_balance_adjust && anim_dt > 0.0f) {
        const float foot_yaw_prev = prev->m_abs_ang.y;
        const float foot_yaw_now = record->m_abs_ang.y;
        const float yaw_delta = math::angle_diff(foot_yaw_now, foot_yaw_prev);
        const float yaw_speed = fabsf(yaw_delta / anim_dt);

        const bool fast_turn = yaw_speed > 120.0f;
        const bool snapped_to_body = fabsf(math::angle_diff(foot_yaw_now, record->m_body)) < 5.0f;

        if (fast_turn && snapped_to_body && adjust.m_fl_cycle < 0.2f) {
            return record->m_body;
        }
    }

    const float abs_yaw_delta = fabsf(math::angle_diff(record->m_abs_ang.y, prev->m_abs_ang.y));
    const float body_yaw_delta = fabsf(math::angle_diff(record->m_body, prev->m_body));

    if (abs_yaw_delta > 58.f && body_yaw_delta < 5.f) {
        return math::normalized_angle(record->m_body + 180.0f);
    }

    return math::normalized_angle(prev->m_eye_angles.y + body_delta);
}

static float pred_foot_yaw(const lag_record& a, const lag_record& b, float predicted_offset) {
    constexpr float foot_speed = 80.0f; // i got this from my ass, its good

    const float old_yaw = a.m_body;
    const float new_yaw = b.m_body;
    const float dt = b.m_anim_time - a.m_anim_time;

    if (dt <= 0.0f)
        return old_yaw;

    const float max_delta = foot_speed * dt;
    const float body_delta = math::normalized_angle(new_yaw - old_yaw);
    const float abs_foot_delta = math::angle_diff(b.m_abs_ang.y, a.m_abs_ang.y);

    const float blended_delta = (body_delta * 0.5f) + (abs_foot_delta * 0.5f);
    const float abs_blended = fabsf(blended_delta);

    float resolved;
    if (abs_blended <= max_delta) {
        resolved = old_yaw + blended_delta;
    }
    else {
        resolved = old_yaw + copysignf(max_delta, blended_delta);
        resolved = math::normalized_angle(resolved + predicted_offset);
    }

    return math::normalized_angle(resolved);
}

static bool lby_spam(const lag_record& curr, const lag_record& prev) {
    const auto& layer0_curr = curr.m_layers[0];
    const auto& layer0_prev = prev.m_layers[0];

    return (
        layer0_curr.m_n_sequence == layer0_prev.m_n_sequence &&
        layer0_curr.m_fl_cycle < layer0_prev.m_fl_cycle &&
        fabsf(layer0_curr.m_fl_playback_rate - layer0_prev.m_fl_playback_rate) > 0.02f
    );   
}

void resolver::resolve_stand(aim_player* data, lag_record* record, csgo_player_anim_state* state) {
    float away = get_away_angle(record);
    move_data_t* move = &data->m_walk_record;

    c_animation_layer* adjust = &record->m_layers[animation_layer_adjust];
    lag_record* prev = find_previous_record(data);

    // hhh, lil paste
    if (move->m_sim_time > 0.f) {
        vec3_t delta = move->m_origin - record->m_origin;
        if (delta.length() <= 128.f) {
            data->m_moved = true;
        }
    }

    int act = data->m_player->get_sequence_activity(adjust->m_n_sequence);
    if (prev) {
        const auto& prev_adjust = prev->m_layers[animation_layer_adjust];

        const bool adjust_sequence_valid =
            adjust->m_n_sequence == 979 || adjust->m_n_sequence == 978;

        const bool adjust_reset =
            prev_adjust.m_fl_cycle > 0.8f && adjust->m_fl_cycle < 0.2f;

        const bool weight_spike =
            (adjust->m_fl_weight - prev_adjust.m_fl_weight > 0.45f) &&
            (adjust->m_fl_weight > 0.9f);

        const bool lby_snap = adjust_sequence_valid && adjust_reset && weight_spike;

        if (lby_snap) {
            data->m_trusted_lby = record->m_body;
            data->m_trusted_lby_time = record->m_anim_time;
            record->m_eye_angles.y = record->m_body;
            return;
        }
    }

    const auto& curr_idle = record->m_layers[11];
    float delta_cycle = 0.0f;
    float delta_playback = 0.0f;

    if (prev) {
        const auto& prev_idle = prev->m_layers[11];
        delta_cycle = fabsf(curr_idle.m_fl_cycle - prev_idle.m_fl_cycle);
        delta_playback = fabsf(curr_idle.m_fl_playback_rate - prev_idle.m_fl_playback_rate);

        if (curr_idle.m_n_sequence == 979 && prev_idle.m_n_sequence == 979) {
            if (delta_cycle < 0.01f && delta_playback < 0.005f)
                data->m_fake_idle_ticks++;
            else
                data->m_fake_idle_ticks = 0;

            if (data->m_fake_idle_ticks > 2) {
                record->m_eye_angles.y = get_away_angle(record) + 180.f;
                return;
            }
        }
    }

    if (act == act_csgo_idle_turn_balance_adjust && prev) {
        const float last_foot_yaw = prev->m_abs_ang.y;
        const float curr_foot_yaw = record->m_abs_ang.y;
        const float last_body = prev->m_body;
        const float dt = record->m_anim_time - prev->m_anim_time;

        if (dt > 0.0f) {
            float yaw_delta = math::angle_diff(curr_foot_yaw, last_foot_yaw);
            float yaw_speed = fabsf(yaw_delta / dt);

            const bool turned_fast = yaw_speed > 120.0f;
            const bool aligned_with_body = fabsf(math::angle_diff(curr_foot_yaw, record->m_body)) < 5.0f;
            const bool adjust_cycle_low = adjust->m_fl_cycle < 0.2f && adjust->m_fl_weight > 0.9f;

            if (turned_fast && aligned_with_body && adjust_cycle_low) {
                record->m_eye_angles.y = record->m_body;
                return;
            }
        }
    }

    if (data->m_moved) {
        float delta = record->m_anim_time - move->m_anim_time;

        if (delta < 0.22f) { // someone, fix this..
            record->m_eye_angles.y = move->m_body;
            return;
        }
        else if (record->m_anim_time >= data->m_body_update) {
            if (data->m_body_index <= 3) {
                record->m_eye_angles.y = record->m_body;
                data->m_body_update = record->m_anim_time + 1.1f;
                return;
            }

            record->m_eye_angles.y = move->m_body;

            if (!(data->m_stand_index % 3))
                record->m_eye_angles.y += g_main.random_float(-35.f, 35.f);

            if (data->m_stand_index > 6 && act != act_csgo_idle_turn_balance_adjust)
                record->m_eye_angles.y = move->m_body + 180.f;
            else if (data->m_stand_index > 4 && act != act_csgo_idle_turn_balance_adjust)
                record->m_eye_angles.y = away + 180.f;

            return;
        }
    }

    if (data->m_records.size() >= 2) {
        const auto& a = *data->m_records[data->m_records.size() - 2];
        const auto& b = *data->m_records[data->m_records.size() - 1];

        std::deque<std::shared_ptr<lag_record>> shared_records;
        for (const auto& rec : data->m_records) {
            if (rec)
                shared_records.push_back(std::make_shared<lag_record>(*rec));
        }

        float predicted_offset = pred_foot_delta(shared_records);

        if (fabsf(predicted_offset) > 1.0f) {
            record->m_eye_angles.y = pred_foot_yaw(a, b, predicted_offset); // easiest headshot ever of my life, god bless
        }
        else {
            record->m_eye_angles.y = calculate_stand(data, record, &a, state);
        }

        return;
    }


    if (data->m_records.size() >= 4) {
        float curvature = curvature_heuristic(data->m_records);

        if (fabsf(curvature) > 40.0f) { // this is insane.. all cheats will suffer
            const auto& a = *data->m_records[data->m_records.size() - 2];
            const auto& b = *data->m_records[data->m_records.size() - 1];

            float predicted_offset = pred_foot_delta(data->m_records);
            float predicted_yaw = pred_foot_yaw(a, b, predicted_offset);

            record->m_eye_angles.y = predicted_yaw;
            return;
        }
    }

    {
        if (state) {
            const float foot_yaw = record->m_abs_ang.y;
            const float width_factor = 1.0f;
            const float yaw_max = state->m_fl_aim_yaw_max * width_factor;
            const float yaw_min = state->m_fl_aim_yaw_min * width_factor;

            // clamp the predicted deltas
            const float dy = math::angle_diff(record->m_body, foot_yaw); // real yaw ≈ body in this case, it will intersect because its close enough, recommended to safe point here
            float corrected_yaw = foot_yaw;

            if (dy > yaw_max - 0.5f && dy < yaw_max + 0.5f) {
                corrected_yaw = foot_yaw + yaw_max;
                record->m_eye_angles.y = math::normalized_angle(corrected_yaw);
                return;
            }
            else if (dy < yaw_min + 0.5f && dy > yaw_min - 0.5f) {
                corrected_yaw = foot_yaw + yaw_min;
                record->m_eye_angles.y = math::normalized_angle(corrected_yaw);
                return;
            }
        }
    }

    if (data->m_records.size() >= 2) {
        const auto& prev = *data->m_records[data->m_records.size() - 2].get();
        const auto& curr = *data->m_records[data->m_records.size() - 1].get();

        if (lby_spam(curr, prev)) {
            record->m_eye_angles.y = math::normalized_angle(prev.m_body + 180.f);
            return;
        }
    }

    const auto& layer0 = record->m_layers[0];
    const float body = record->m_body;
    const float away_normal = away;
    const float fl_weight = adjust->m_fl_weight;
    const float fl_cycle = adjust->m_fl_cycle;

    bool is_adjust = act == act_csgo_idle_turn_balance_adjust;
    bool is_mad = (fl_weight < 0.2f && fl_cycle > 0.01f && fl_cycle < 0.9f);
    bool is_lol = (
        layer0.m_fl_playback_rate > 0.96f &&
        layer0.m_fl_cycle < 0.07f &&
        prev && layer0.m_n_sequence == prev->m_layers[0].m_n_sequence &&
        !is_adjust
    );
    bool is_fake_idle = (adjust->m_n_sequence == 979 && fl_cycle < 0.01f); // idle_adjust fake layer spam, dont use this bs

    int index = data->m_stand_index2 % 6;

    switch (index) { // retard anti brute.. delete it
    case 0:
        // hahaha otc method
        record->m_eye_angles.y = away_normal + 180.f;
        break;

    case 1:
        // lol, why?
        record->m_eye_angles.y = body;
        break;

    case 2:
        // fake left
        if (is_mad)
            record->m_eye_angles.y = body + 70.f;
        else
            record->m_eye_angles.y = body + 110.f;
        break;

    case 3:
        // fake right
        if (is_mad)
            record->m_eye_angles.y = body - 70.f;
        else
            record->m_eye_angles.y = body - 110.f;
        break;

    case 4:
        // ahahahahah, its not 2020 anymore..
        if (is_fake_idle || is_lol)
            record->m_eye_angles.y = away_normal + g_main.random_float(-25.f, 25.f);
        else
            record->m_eye_angles.y = away_normal + 180.f + g_main.random_float(-20.f, 20.f);
        break;
    }

    record->m_eye_angles.y = math::normalized_angle(record->m_eye_angles.y);
}

wantx · 6/17/25

this is a joke?

deteqafsafasf · 6/18/25

wantx said:
this is a joke?

no is realy good

austino · 6/18/25

i lit jus added ts to my paste and i have the best hake +rep 10/10 trustpilot

skeetttttt · 6/18/25

IS THIS JACKW CODEO MG

bitcoinbandit · 6/18/25

Great release brother

kartoche · 6/19/25

kekw

zaneATAT · 6/19/25

This is more memey than my resolvers

kanyewest · 6/20/25

zaneATAT said:
This is more memey than my resolvers

ur a meme in general dw

sennatoor · 6/21/25

supremacy with the femboy coding style rofl insane, i hope this is a memepost btw please dont use this

zDrip · 6/22/25

meme post /del

Plisskien · 6/22/25

wantx said:
this is a joke?

zaneATAT said:
This is more memey than my resolvers

sennatoor said:
supremacy with the femboy coding style rofl insane, i hope this is a memepost btw please dont use this

zDrip said:
meme post /del

I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

haruki · 6/22/25

DestroyLonely said:
width_factor

blessed by jack?!

Giuseppe · 6/22/25

Plisskien said:
I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

welcome to the ego boosted skids that think they know everything

wantx · 6/22/25

Plisskien said:
I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

1. Over-Dependency on Animation Layer Heuristics

It relies heavily on specific animation layer sequences like 979 / 978 and precise weight/cycle thresholds.
In CS:GO 2018, animation syncing is inconsistent. The logic like:
cpp
CopiarEditar
if (adjust.m_n_sequence == 979 || adjust.m_n_sequence == 978)
becomes unreliable, especially on laggy players or desynced servers. These layers may not reset or behave consistently in legacy builds.

2. Bad Handling of Broken AnimStates

Legacy CS:GO had bugs that could break the animation state (e.g. stuck layers, looping sequences).
The resolver assumes animstate is always valid, but it lacks sanity checks when using:
cpp
CopiarEditar
const float yaw_max = state->m_fl_aim_yaw_max;
If state is broken (e.g. due to teleport, choke, fake lag), this logic results in completely incorrect desync calculation.

3. Inaccurate pred_foot_delta Logic

The pred_foot_delta function tries to determine fake yaw deltas using only body yaw deltas, like so:
cpp
CopiarEditar
float delta = math::normalized_angle(curr->m_body - prev->m_body);
This fails completely when m_body is clamped or fake updates occur. In CS:GO 2018, m_body can snap or stall, giving false positives or missing actual fakes.

4. Curvature Heuristic is Highly Unstable

The curvature_heuristic attempts to model yaw change acceleration. But it's noisy:
cpp
CopiarEditar
curvature += velocity - velocity[i - 1];
[*]Small errors in m_body or anim_time massively skew this.
[*]In 2018 CS:GO, m_body updates are often missing/skipped due to server choke, which destroys the math behind curvature detection.

5. Magic Numbers and Random Guessing

Many parts of the code rely on completely arbitrary numbers or randomness:
cpp
CopiarEditar
if (!(data->m_stand_index % 3))
record->m_eye_angles.y += g_main.random_float(-35.f, 35.f);
or:
cpp
CopiarEditar
constexpr float foot_speed = 80.0f; // i got this from my ass, its good

These may work in modern CS:GO with cleaner netcode, but they fail catastrophically in legacy, where movement is less predictable.

6. No High Confidence Resolver Logic (e.g. LBY Timers)

It doesn't implement tick-based LBY update detection or break prediction timers, which were crucial in 2018 for resolving real vs fake body yaw.

There's no use of next_lby_update_time, lby_timer, or even server_tick % interval strategies.

7. No Pose Parameter Analysis

2018 legacy had m_flPoseParameter[6] (yaw) and m_flPoseParameter[11] (move lean) as critical indicators of real yaw.

This resolver does not use pose parameters at all, which is a massive weakness in the legacy environment.

8. Doesn’t Consider Network Fakelag Conditions

It fails to account for:

choke amount

last valid tick

simulation time vs server time

Without this, it can’t properly backtrack records, especially during peeks or teleports.

9. No Multi-Record Bruteforce Scanning

Many legacy cheats like Skeet/Neverlose used multi-angle bruteforce history checks.

This resolver applies only one guess per tick, no reinforcement learning, and no memory of previous misses, reducing adaptability.

10. Bad Anti-Bruteforce Fallbacks

The fallback section uses simplistic rotation logic:
cpp

switch (index) {
case 0: record->m_eye_angles.y = away + 180.f;
case 1: record->m_eye_angles.y = body;
...
}

These fallbacks are easily predicted and offer no real logic or confidence system behind them.

In 2018, many players used fake angles close to real body yaw, so hardcoded ±110° offsets are too extreme and miss often.

11. No Lag Compensation Validation

There's no check if the record is valid, extrapolated, dormant, or broken.

Legacy tick base manipulations (like fake duck, micro move, teleport, broken sim) cause completely invalid resolver inputs.

12. Unstable on Micro-Movement or Fake Duck

Resolver does not check for:

micro-move triggers (small velocity changes that break fake logic)

fake duck detection (ground flags + animation stalls)

These are frequent in 2018, and they easily confuse the resolver.

Giuseppe · 6/23/25

wantx said:
1. Over-Dependency on Animation Layer Heuristics

It relies heavily on specific animation layer sequences like 979 / 978 and precise weight/cycle thresholds.

In CS:GO 2018, animation syncing is inconsistent. The logic like:
cpp
CopiarEditar
if (adjust.m_n_sequence == 979 || adjust.m_n_sequence == 978)
becomes unreliable, especially on laggy players or desynced servers. These layers may not reset or behave consistently in legacy builds.

2. Bad Handling of Broken AnimStates

Legacy CS:GO had bugs that could break the animation state (e.g. stuck layers, looping sequences).

The resolver assumes animstate is always valid, but it lacks sanity checks when using:
cpp
CopiarEditar
const float yaw_max = state->m_fl_aim_yaw_max;
If state is broken (e.g. due to teleport, choke, fake lag), this logic results in completely incorrect desync calculation.

3. Inaccurate pred_foot_delta Logic

The pred_foot_delta function tries to determine fake yaw deltas using only body yaw deltas, like so:
cpp
CopiarEditar
float delta = math::normalized_angle(curr->m_body - prev->m_body);

This fails completely when m_body is clamped or fake updates occur. In CS:GO 2018, m_body can snap or stall, giving false positives or missing actual fakes.

4. Curvature Heuristic is Highly Unstable

The curvature_heuristic attempts to model yaw change acceleration. But it's noisy:
cpp
CopiarEditar
curvature += velocity - velocity[i - 1];
[*]Small errors in m_body or anim_time massively skew this.
[*]In 2018 CS:GO, m_body updates are often missing/skipped due to server choke, which destroys the math behind curvature detection.

5. Magic Numbers and Random Guessing

Many parts of the code rely on completely arbitrary numbers or randomness:
cpp
CopiarEditar
if (!(data->m_stand_index % 3))
record->m_eye_angles.y += g_main.random_float(-35.f, 35.f);
or:
cpp
CopiarEditar
constexpr float foot_speed = 80.0f; // i got this from my ass, its good

These may work in modern CS:GO with cleaner netcode, but they fail catastrophically in legacy, where movement is less predictable.

6. No High Confidence Resolver Logic (e.g. LBY Timers)

It doesn't implement tick-based LBY update detection or break prediction timers, which were crucial in 2018 for resolving real vs fake body yaw.

There's no use of next_lby_update_time, lby_timer, or even server_tick % interval strategies.

7. No Pose Parameter Analysis

2018 legacy had m_flPoseParameter[6] (yaw) and m_flPoseParameter[11] (move lean) as critical indicators of real yaw.

This resolver does not use pose parameters at all, which is a massive weakness in the legacy environment.

8. Doesn’t Consider Network Fakelag Conditions

It fails to account for:

choke amount

last valid tick

simulation time vs server time

Without this, it can’t properly backtrack records, especially during peeks or teleports.

9. No Multi-Record Bruteforce Scanning

Many legacy cheats like Skeet/Neverlose used multi-angle bruteforce history checks.

This resolver applies only one guess per tick, no reinforcement learning, and no memory of previous misses, reducing adaptability.

10. Bad Anti-Bruteforce Fallbacks

The fallback section uses simplistic rotation logic:
cpp

switch (index) {
case 0: record->m_eye_angles.y = away + 180.f;
case 1: record->m_eye_angles.y = body;
...
}

These fallbacks are easily predicted and offer no real logic or confidence system behind them.

In 2018, many players used fake angles close to real body yaw, so hardcoded ±110° offsets are too extreme and miss often.

11. No Lag Compensation Validation

There's no check if the record is valid, extrapolated, dormant, or broken.

Legacy tick base manipulations (like fake duck, micro move, teleport, broken sim) cause completely invalid resolver inputs.

12. Unstable on Micro-Movement or Fake Duck

Resolver does not check for:

micro-move triggers (small velocity changes that break fake logic)

fake duck detection (ground flags + animation stalls)

These are frequent in 2018, and they easily confuse the resolver.

chat gpt aa

zaneATAT · 6/24/25

Plisskien said:
I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

No clarification comments, instead its meme stuff that don't explain anything
Weird variable names
He's calculating body delta as delta between 2 previous lbys
Distorting or even some non distorting players will set their lby break to the previous lby angle so you don't catch it updating, and even if you predict it, the delta will be 0 which is meaningless

But honestly i think youre right
For my response i read it carefully and it doesn't seem as memey as i thought
There are things i do not understand that would need actual comments but thats skill issue on my part
It's not perfect, but it's something different

skeetttttt · 6/24/25

holy chatgpt

pxnch420 · 6/28/25

Plisskien said:
I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

Matter of fact this is a full troll post, almost all of the anim code used here is complete bullshit and doesn’t make sense (layer 3 sequence compared to an act, layer 6 act compared to a layer 3 activity etc)

zDrip · 7/5/25

Plisskien said:
I'm happy to see so many people assess this resolver in such a meaningful way. It shows that you don't know anything about it, while in my honest opinion, if somebody is interested in providing their opinion, it should be based more on an objective approach. Thus, next time, if anybody is intertwined in providing such opinion, I would love to see it in that way. I'm not an expert in this field, since this is not my cup of tea, but I can tell that this resolver seems to be reasonable for legacy 2018 due to the fact of using an animation layer that seems to be properly applied, and sophisticated LBY detection. While there is much ground for improvement, e.g., a more advanced brute-force fallback and cleaner code, overall this resolver seems to be not that bad.

dude, any one who knows anything about resolving will scroll through this and scratch their head, there is nothing to give back to people who just brainlessly post obviously pasted code without any thoughts behind it.
the desync calc is wrong, lby code only uses client code, the function names are obviously ai (or just made to be different on purpose which is even more cringe). again, if this was a geniuine post about resolving or someone asking for help, none of the comments you replied to (including mine) would have been posted, but posts like this have just been there for years and its tireing.

pxnch420 said:
Matter of fact this is a full troll post, almost all of the anim code used here is complete bullshit and doesn’t make sense (layer 3 sequence compared to an act, layer 6 act compared to a layer 3 activity etc)

youre just as clueless. the games code is public, educate yourself.

You must be registered for see links

and to this day, its like this in the games code.

yes, he got the second activity wrong but thats besides the point.

Welcome to HvH Forum!

Source Code strong 2018 resolver

Newbie HvHer

Newbie HvHer

Newbie HvHer

Freaky 🔥❤️‍🔥

Newbie HvHer

Rookie HvHer

Rookie HvHer

Expert HvHer

Newbie HvHer

Newbie HvHer

Newbie HvHer

I'm not Plisskien

Rookie HvHer

Wine Lover

Newbie HvHer

1. Over-Dependency on Animation Layer Heuristics​

2. Bad Handling of Broken AnimStates​

3. Inaccurate pred_foot_delta Logic​

4. Curvature Heuristic is Highly Unstable​

5. Magic Numbers and Random Guessing​

6. No High Confidence Resolver Logic (e.g. LBY Timers)​

7. No Pose Parameter Analysis​

8. Doesn’t Consider Network Fakelag Conditions​

9. No Multi-Record Bruteforce Scanning​

10. Bad Anti-Bruteforce Fallbacks​

11. No Lag Compensation Validation​

12. Unstable on Micro-Movement or Fake Duck​

Wine Lover

1. Over-Dependency on Animation Layer Heuristics​

2. Bad Handling of Broken AnimStates​

3. Inaccurate pred_foot_delta Logic​

4. Curvature Heuristic is Highly Unstable​

5. Magic Numbers and Random Guessing​

6. No High Confidence Resolver Logic (e.g. LBY Timers)​

7. No Pose Parameter Analysis​

8. Doesn’t Consider Network Fakelag Conditions​

9. No Multi-Record Bruteforce Scanning​

10. Bad Anti-Bruteforce Fallbacks​

11. No Lag Compensation Validation​

12. Unstable on Micro-Movement or Fake Duck​

Expert HvHer

Newbie HvHer

Rookie HvHer

Newbie HvHer

Similar threads

Newest members

Partners

Forum statistics

Online statistics

1. Over-Dependency on Animation Layer Heuristics

2. Bad Handling of Broken AnimStates

3. Inaccurate pred_foot_delta Logic

4. Curvature Heuristic is Highly Unstable

5. Magic Numbers and Random Guessing

6. No High Confidence Resolver Logic (e.g. LBY Timers)

7. No Pose Parameter Analysis

8. Doesn’t Consider Network Fakelag Conditions

9. No Multi-Record Bruteforce Scanning

10. Bad Anti-Bruteforce Fallbacks

11. No Lag Compensation Validation

12. Unstable on Micro-Movement or Fake Duck

1. Over-Dependency on Animation Layer Heuristics

2. Bad Handling of Broken AnimStates

3. Inaccurate pred_foot_delta Logic

4. Curvature Heuristic is Highly Unstable

5. Magic Numbers and Random Guessing

6. No High Confidence Resolver Logic (e.g. LBY Timers)

7. No Pose Parameter Analysis

8. Doesn’t Consider Network Fakelag Conditions

9. No Multi-Record Bruteforce Scanning

10. Bad Anti-Bruteforce Fallbacks

11. No Lag Compensation Validation

12. Unstable on Micro-Movement or Fake Duck