Исходник Actually Decent Resolving Methods

[PIPIDUROKARAILEK]

honestly cant tell if youre joking or not. layer 3 does not "always return zero" i think youre mistaken

u NEVER printed animlayers to see values? layer 3 always is 0

layers 1 and 2 are useless but 6 is not at all. if you store your matrix and get their proper playback rate

print layer 6 playback rate and u will see is very useless (the value that returns u can't use in nothing). U'r saying that cuz some peoples posted "notap resolver" with layer 6

also "decent" when thats literally just a basic brute force? how are you gonna criticize that lmao

yes cuz it's an bruteforce that after 3 shots set 180 nice

nd "wtf is that???" its a basic lby detection based resolver which ive used for years

"and its absolutely not the same shit as alot of this shit is my actual code from my personal project"

Bro have an other way to detect side (not using animlayers and lby) is 100x better than that

 

[mob_pp_lover]

u NEVER printed animlayers to see values? layer 3 always is 0


print layer 6 playback rate and u will see is very useless (the value that returns u can't use in nothing). U'r saying that cuz some peoples posted "notap resolver" with layer 6


yes cuz it's an bruteforce that after 3 shots set 180 nice



"and its absolutely not the same shit as alot of this shit is my actual code from my personal project"

Bro have an other way to detect side (not using animlayers and lby) is 100x better than that

youre just straight up wrong. you obviously just printed layer 6 without rebuilding it if you deadass think its useless lmao

 

[PIPIDUROKARAILEK]

youre just straight up wrong. you obviously just printed layer 6 without rebuilding it if you deadass think its useless lmao

pls stop

 

[gra437]

hello my Russian friends. ive seen a ton of "resolvers" on here and they're useless and shit. ill go over some ACTUALLY decent resolving methods here so, get your google translate out and stay tuned.

opposites: not the best choice, but it has its place and you'll find out why later

// less advanced
float EyeDelta = player->EyeAngles().y - animstate->goalfeetyaw;
int Side = (EyeDelta > 0.f) ? -1 : 1;

animstate->goalfeetyaw = player->EyeAngles().y + desync_delta * Side;

// more advanced
float EyeDelta = player->EyeAngles().y - animstate->goalfeetyaw;
bool LowDelta = EyeDelta <= 30.f;
int Side = (EyeDelta > 0.f) ? -1 : 1;
float desync_delta = LowDelta ? player->MaxDesync() / 2 : player->MaxDesync();

switch (missedshots)
{
    case 0: animstate->goalfeetyaw = player->EyeAngles().y + desync_delta * Side; break;
    case 1: animstate->goalfeetyaw = player->EyeAngles().y + desync_delta * -Side; break;
    case 2: animstate->goalfeetyaw = 180.f;
}

anti-freestand: a safer choice than opposites. theres different ways to do this but i suggest using stickrpg's anti freestand. also you can use it in combination with opposites to cross reference the different angles

    for (int i = 1; i < interfaces.engine->GetMaxClients(); ++i)
    {
        auto player = interfaces.ent_list->GetClientEntity(i);

        if (!player || !player->isAlive() || player->IsDormant() || player->GetTeam() == csgo->local->GetTeam())
            continue;

        bool Autowalled = false, HitSide1 = false, HitSide2 = false;
        auto idx = player->GetIndex();
        float angToLocal = Math::CalculateAngle(csgo->local->GetOrigin(), player->GetOrigin()).y;
        Vector ViewPoint = csgo->local->GetOrigin() + Vector(0, 0, 90);
        Vector2D Side1 = { (30 * sin(DEG2RAD(angToLocal))),(30 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side2 = { (30 * sin(DEG2RAD(angToLocal + 180))) ,(30 * cos(DEG2RAD(angToLocal + 180))) };
        Vector2D Side3 = { (60 * sin(DEG2RAD(angToLocal))),(60 * cos(DEG2RAD(angToLocal))) };
        Vector2D Side4 = { (60 * sin(DEG2RAD(angToLocal + 180))) ,(60 * cos(DEG2RAD(angToLocal + 180))) };

        Vector Origin = player->GetOrigin();

        Vector2D OriginLeftRight[] = { Vector2D(Side1.x, Side1.y), Vector2D(Side2.x, Side2.y) };
        Vector2D OriginHighLeftRight[] = { Vector2D(Side3.x, Side3.y), Vector2D(Side4.x, Side4.y) };

        for (int side = 0; side < 2; side++)
        {
            Vector OriginAutowall = { Origin.x + OriginLeftRight[side].x,  Origin.y - OriginLeftRight[side].y , Origin.z + 90 };
            Vector OriginAutowall2 = { ViewPoint.x + OriginHighLeftRight[side].x,  ViewPoint.y - OriginHighLeftRight[side].y , ViewPoint.z };

            if (g_AutoWall.CanHitFloatingPoint(OriginAutowall, ViewPoint))
            {
                if (side == 0)
                {
                    HitSide1 = true;
                    FreestandSide[idx] = -1;
                }
                else if (side == 1)
                {
                    HitSide2 = true;
                    FreestandSide[idx] = 1;
                }

                Autowalled = true;
            }
            else
            {
                for (int side222 = 0; side222 < 2; side222++)
                {
                    Vector OriginAutowallHigh = { Origin.x + OriginLeftRight[side222].x,  Origin.y - OriginLeftRight[side222].y , Origin.z + 90 };

                    if (g_AutoWall.CanHitFloatingPoint(OriginAutowallHigh, OriginAutowall2))
                    {
                        if (side222 == 0)
                        {
                            HitSide1 = true;
                            FreestandSide[idx] = -1;
                        }
                        else if (side222 == 1)
                        {
                            HitSide2 = true;
                            FreestandSide[idx] = 1;
                        }

                        Autowalled = true;
                    }
                }
            }

            if (!Autowalled)
                FreestandSide[idx] = 0;
        }
    }

animlayers: now we're getting into big brain territory where i see tons of people messing up and not doing it right. for each layer you make you need to have THAT layer relate to a matrix or you're not really doing anything at all. example:

    player->UpdateClientSideAnimation();

    float EyeDelta = player->GetEyeAngles().y - animstate->m_flGoalFeetYaw;

    std::memcpy(csgo->MoveLayers[0][6], player->GetAnimOverlay(6), 0x38 * int(player->GetAnimOverlays()));
    player->SetupBones(csgo->zero, 128, 0x7FF00, interfaces.global_vars->curtime);

    if (EyeDelta < 0.f)
    {
        std::memcpy(csgo->MoveLayers[1][6], player->GetAnimOverlay(6), 0x38 * int(player->GetAnimOverlays()));
        player->SetupBones(csgo->positive, 128, 0x7FF00, interfaces.global_vars->curtime);
    }
    else
    {
        std::memcpy(csgo->MoveLayers[2][6], player->GetAnimOverlay(6), 0x38 * int(player->GetAnimOverlays()));
        player->SetupBones(csgo->negative, 128, 0x7FF00, interfaces.global_vars->curtime);
    }

make sure you set your fucking matrices and your layers im sick of seeing people just make 3 pseudo layers that dont do shit and using them to resolve its dumb.
also im not putting the calculations you need to find side off of animlayers cause its been posted a million times.

tracing: personally i hate tracing i think its basically useless, BUT if you actually set your vectors and matrices properly it might not be the worst idea

    Vector current;
    float back_two, right_two, left_two;
    trace_t tr;
    Ray_t ray, ray2, ray3;
    CTraceFilter filter;

    Vector right(player->GetEyeAngles().x, player->GetEyeAngles().y + player->MaxDesyncDelta(), player->GetEyeAngles().z);
    Vector left(player->GetEyeAngles().x, player->GetEyeAngles().y - player->MaxDesyncDelta(), player->GetEyeAngles().z);
    Vector back(player->GetEyeAngles().x, 180.f, player->GetEyeAngles().z);
    current = player->GetEyeAngles();

    filter.pSkip = player;
    float distance = /*whatever*/;
    ray.init(current, right);
    ray2.init(current, left);
    ray3.init(current, back);

    float back_one, right_one, left_one;

    right_one = current.y - right.y;
    left_one = current.y - left.y;
    back_one = current.y - back.y;

    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);
    right_two = tr.endpos.Length2D() - tr.startpos.Length2D();

    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);
    left_two = tr.endpos.Length2D() - tr.startpos.Length2D();

    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);
    back_two = tr.endpos.Length2D() - tr.startpos.Length2D();

    *side = 0;

    // if extending we have an easier time finding their real
    if (player->GetAnimOverlay(3)->m_flCycle == 0.f && player->GetAnimOverlay(3)->m_flWeight == 0.f)
    {
        if (fabs(right_one) >= player->MaxDesyncDelta())
            *side = 1;
        else if (fabs(left_one) >= player->MaxDesyncDelta())
            *side = -1;
        else if (fabs(back_one) >= player->MaxDesyncDelta())
            *side = 0;
    }
    // else we use tracing
    else
    {
        if (fabs(right_two) >= distance)
            *side = 1;
        else if (fabs(left_two) >= distance)
            *side = -1;
        else if (fabs(back_two) >= distance)
            *side = 0;
    }

there are a few reasons to use tracing. tracing can sometimes give us safer and "stricter" resolves because tracing uses actual in game distance. experiment, the tracing code i put works better than others but its still FAR from perfect.

lby: usually doesnt work anymore, majority of cheats use micromovements now but in the off chance you come across an aimware user this is a pretty easy resolve. the idea is you check their lby angle when they set off sequence 979, their lby angle will almost always flick towards their fake which should (in theory) allow us to get a good resolve

int LbySide = 0;

if (player->GetAnimOverlay(3)->m_nSequence == 979 && player->GetVecVelocity().Length2D() == 0.f)
{
    float LbyAngle = player->GetLowerBodyYaw();
   
    LbySide = (LbyAngle > 0.f) ? -1 : 1;
}

animstate->goalfeetyaw = player->GetEyeAngles().y + desync_delta * LbySide;

alright thats about it. dont paste any of this by the way its all just for examples. you need to build these different methods IN YOUR ACTUAL SOURCE or else majority of them will return tons of errors or you'll fuck something up and they just wont work at all. good luck!

The tracing makes no sense to me. You are creating points in space that correspond to angles, which makes no sense. Then you are then simulating a bullet that dies with MASK_SHOT, aka anything solid, a finally comparing the distances (between start and end of impact) to some arbitrary distance (commented whatever). This... makes no sense. If you simulated where a players head would be if desyncing one way or the other, and compared the distances of where the players head was it might make more sense, currently I just don't understand how you can create points in space from angles. (at least in the way that you did)

 

[mob_pp_lover]

If you simulated where a players head would be if desyncing one way or the other, and compared the distances of where the players head was it might make more sense

you create vectors of simulated angles and the current angle as seen in the op

    Vector right(player->GetEyeAngles().x, player->GetEyeAngles().y + player->MaxDesyncDelta(), player->GetEyeAngles().z);
    Vector left(player->GetEyeAngles().x, player->GetEyeAngles().y - player->MaxDesyncDelta(), player->GetEyeAngles().z);

^ simulated sides

    Vector back(player->GetEyeAngles().x, 180.f, player->GetEyeAngles().z);

^ simulated back angle

current = player->GetEyeAngles();

^ and current angle

    right_one = current.y - right.y;
    left_one = current.y - left.y;
    back_one = current.y - back.y;

    interfaces.trace->TraceRay(ray, MASK_SHOT, &filter, &tr);
    right_two = tr.endpos.Length2D() - tr.startpos.Length2D();

    interfaces.trace->TraceRay(ray2, MASK_SHOT, &filter, &tr);
    left_two = tr.endpos.Length2D() - tr.startpos.Length2D();

    interfaces.trace->TraceRay(ray3, MASK_SHOT, &filter, &tr);
    back_two = tr.endpos.Length2D() - tr.startpos.Length2D();

^ distance from simulated angles

        if (fabs(right_two) >= distance)
            *side = 1;
        else if (fabs(left_two) >= distance)
            *side = -1;
        else if (fabs(back_two) >= distance)
            *side = 0;

^ compare and resolve

 

[VladislavAchziger]

Напоминает не много переделаный ресольвер из антарио

 

[Jow1]

is it possible to hit the lby flick ?

 

[mob_pp_lover]

is it possible to hit the lby flick ?

possibly but its unlikely you'll find someone using aa with a visible lby flick. in that case once layer3's sequence equal 939 just set their angle to their lby

 

[mob_pp_lover]

so you try to "explain" stuff you just found in diff sources you pasted off? it seems like you just collected code like all of those ruski idiots here instead of even understanding what it is "trying" to achieve.


as off the animation update lby updates can also happen in choke cycle which means no unless u face some retard pasters

already explained that to him.

also the entire point of this post is explaining commonly posted shitty resolving methods and making them better. or like with my animlayer code, actually properly setting matrices and explaining why you need to. i explained every method here thoroughly and gave proper public (and private, as setting matrices is nothing ive seen explained and barely even shown here) resolve methods people can use to learn off of and build off of. if you already know everything, good for you, this post isnt made for you lmao

 

[monsterflyffplayer]

already explained that to him.

also the entire point of this post is explaining commonly posted shitty resolving methods and making them better. or like with my animlayer code, actually properly setting matrices and explaining why you need to. i explained every method here thoroughly and gave proper public (and private, as setting matrices is nothing ive seen explained and barely even shown here) resolve methods people can use to learn off of and build off of. if you already know everything, good for you, this post isnt made for you lmao

the only thing youdid is pasting otc reversal and post it here without explaining why it works.
also the rest of "your" code is pure bullshit and wont work properly, seeing your code shows me the you prob fucked your anims too which makes it useless anyways ?

also the first otc anim code post i already posted that you have to set the matrices properly, nothing to learn off of this post just same trash code as already posted 100 times

 

[mob_pp_lover]

the only thing youdid is pasting otc reversal and post it here without explaining why it works.
also the rest of "your" code is pure bullshit and wont work properly, seeing your code shows me the you prob fucked your anims too which makes it useless anyways ?

also the first otc anim code post i already posted that you have to set the matrices properly, nothing to learn off of this post just same trash code as already posted 100 times

this code is purely for example purposes but if you gave it some tlc, would all actually work, and not only that the point is to explain methods we already know exist, but are so public they've been posted, pasted, and ruined many times over. you're saying "nothing to learn off of" which means to me you dont see anything you can copy for your shit paste (which is exactly what i wanted). and your post about setting matrices was just telling people to set them, but obviously you wouldnt be able to tell them how to considering you think me showing a basic and proper example of setting anim matrices would "fuck my anims" when it doesnt set or affect your actual animations lmao.

also why would i need to explain why layer6 resolving works when they can literally go look at csgo's dumps or even rebuild and draw layer6 themselves? this isnt a spoon feeding post, its explaining shit that needs to be explained and allowing them to explore what needs to be explored

you are literally a monkey with a type writer

 

[monsterflyffplayer]

this code is purely for example purposes but if you gave it some tlc, would all actually work, and not only that the point is to explain methods we already know exist, but are so public they've been posted, pasted, and ruined many times over. you're saying "nothing to learn off of" which means to me you dont see anything you can copy for your shit paste (which is exactly what i wanted). and your post about setting matrices was just telling people to set them, but obviously you wouldnt be able to tell them how to considering you think me showing a basic and proper example of setting anim matrices would "fuck my anims" when it doesnt set or affect your actual animations lmao.

also why would i need to explain why layer6 resolving works when they can literally go look at csgo's dumps or even rebuild and draw layer6 themselves? this isnt a spoon feeding post, its explaining shit that needs to be explained and allowing them to explore what needs to be explored

you are literally a monkey with a type writer

"this isnt a spoon feeding post" it surely is as seen on ur trash public base syntax, anyways u did not explain anything nor are u able to just another otc paster + ur wall dt code is utter shit and will fail in many cases.