[DestroyLonely]

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

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]

this is a joke?

 

[deteqafsafasf]

this is a joke?

no is realy good

 

[austino]

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

 

[skeetttttt]

IS THIS JACKW CODEO MG

 

[bitcoinbandit]

Great release brother

 

[kartoche]

kekw

 

[zaneATAT]

This is more memey than my resolvers

 

[kanyewest]

This is more memey than my resolvers

ur a meme in general dw

 

[sennatoor]

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

 

[zDrip]

meme post /del

 

[Plisskien]

this is a joke?

This is more memey than my resolvers

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

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]

width_factor

blessed by jack?!

 

[Giuseppe]

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]

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]

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]

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]

holy chatgpt

 

[pxnch420]

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)