SHARE
TWEET

Untitled

a guest Oct 23rd, 2019 65 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include "main.h"
  2. #include "resolver.h"
  3. #include "logshots.hpp"
  4. RecvVarProxyFn OldProxy_Y;
  5.  
  6. enum resolver_state {
  7.     resolver_start,
  8.     resolver_inverse,
  9.     resolver_no_desync,
  10.     resolver_jitter
  11. };
  12.  
  13. enum brute_moving_state {
  14.     resolver_moving_start,
  15.     resolver_moving_start_inverse,
  16.     resolver_moving_inverse,
  17.     resolver_moving_no_desync,
  18.     resolver_moving_jitter
  19. };
  20. float NormalizeYaw(float yaw)
  21. {
  22.     if (yaw > 180)
  23.         yaw -= (round(yaw / 360) * 360.f);
  24.     else if (yaw < -180)
  25.         yaw += (round(yaw / 360) * -360.f);
  26.    
  27.     return yaw;
  28. }
  29.  
  30. float brute_yaw;
  31. float moving_brute_yaw;
  32. resolver_state brute_state{};
  33. brute_moving_state brute_moving_state{};
  34.  
  35. static std::random_device rd;
  36. static std::mt19937 rng(rd());
  37.  
  38. float AAA_Yaw(C_BaseEntity* entity, ClientFrameStage_t stage) {
  39.     int index = entity->GetIndex();
  40.     float angle = gCorrections[index].y;
  41.    
  42.      if (!pEngine->IsInGame())
  43.            return;
  44.        
  45.        C_BasePlayer* localplayer = (C_BasePlayer*) pEntList->GetClientEntity(pEngine->GetLocalPlayer());
  46.        if (!localplayer)
  47.            return;
  48.        
  49.        extern std::array<int, 64> missedShots;
  50.        
  51.        if (vars.aimbot.enabled && vars.aimbot.Yawresolver && stage == ClientFrameStage_t::FRAME_NET_UPDATE_POSTDATAUPDATE_START)
  52.        {
  53.            for (int i = 1; i < pEngine->GetMaxClients(); ++i)
  54.            {
  55.                C_BasePlayer* player = (C_BasePlayer*) pEntList->GetClientEntity(i);
  56.                if (!player
  57.                    || player == localplayer
  58.                    || player->GetDormant()
  59.                    || !player->GetAlive()
  60.                    || player->GetImmune()
  61.                    || player->GetTeam() == localplayer->GetTeam())
  62.                    continue;
  63.                
  64.                CCSGOAnimState* animState = player->GetAnimState();
  65.                if (!animState)
  66.                    continue;
  67.                
  68.                if(vars.aimbot.Yawresolver)
  69.                    continue;
  70.                
  71.                int missedShot = LogShots::missedShots[player->GetIndex() - 1];
  72.                
  73.                bool is_moving = player->GetVelocity().Length2D() > 0.1f && player->GetFlags() & FL_ONGROUND;
  74.                
  75.                if (is_moving) {
  76.                    switch (brute_moving_state)
  77.                    {
  78.                        case resolver_moving_start:
  79.                            brute_moving_state = resolver_moving_start_inverse;
  80.                            break;
  81.                        case resolver_moving_start_inverse:
  82.                            brute_moving_state = resolver_moving_inverse;
  83.                            moving_brute_yaw = -brute_yaw;
  84.                            break;
  85.                        case resolver_moving_inverse:
  86.                            brute_moving_state = resolver_moving_no_desync;
  87.                            moving_brute_yaw = 0.f;
  88.                            break;
  89.                        case resolver_moving_no_desync:
  90.                            brute_moving_state = resolver_moving_jitter;
  91.                            moving_brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
  92.                            break;
  93.                        default:
  94.                        case resolver_moving_jitter:
  95.                            brute_moving_state = resolver_moving_start;
  96.                            moving_brute_yaw = -moving_brute_yaw;
  97.                            break;
  98.                    }
  99.                }
  100.                else {
  101.                    switch (brute_state)
  102.                    {
  103.                        case resolver_start:
  104.                            brute_state = resolver_inverse;
  105.                            brute_yaw = -brute_yaw;
  106.                            break;
  107.                        case resolver_inverse:
  108.                            brute_state = resolver_no_desync;
  109.                            brute_yaw = 0.f;
  110.                            break;
  111.                        case resolver_no_desync:
  112.                            brute_state = resolver_jitter;
  113.                            brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
  114.                            break;
  115.                        default:
  116.                        case resolver_jitter:
  117.                            brute_state = resolver_start;
  118.                            brute_yaw = -brute_yaw;
  119.                            break;
  120.                    }
  121.                }
  122.                switch (brute_state)
  123.                {
  124.                    case resolver_start:
  125.                        brute_state = resolver_inverse;
  126.                        brute_yaw = -brute_yaw;
  127.                        break;
  128.                    case resolver_inverse:
  129.                        brute_state = resolver_no_desync;
  130.                        brute_yaw = 0.f;
  131.                        break;
  132.                    case resolver_no_desync:
  133.                        brute_state = resolver_jitter;
  134.                        brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
  135.                        break;
  136.                    default:
  137.                    case resolver_jitter:
  138.                        brute_yaw = -brute_yaw;
  139.                        break;
  140.                }
  141.                if (missedShot > 2)
  142.                {
  143.                    switch (missedShot % 4) {
  144.                        case 0:
  145.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + 45.0f;
  146.                            break;
  147.                        case 1:
  148.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) - 45.0f;
  149.                            break;
  150.                        case 2:
  151.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw)- 30.0f;
  152.                            break;
  153.                        case 3:
  154.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + 30.0f;
  155.                            break;
  156.                            
  157.                        default:
  158.                            
  159.                            return;
  160.                    }
  161.                }else{
  162.                        const auto slow_walk = player->GetAnimState()->feetYawRate >= 0.01f && player->GetAnimState()->feetYawRate <= 0.8f;
  163.                        
  164.                        if (brute_state == resolver_start)
  165.                            brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -120.0f : 120.0f;
  166.                        
  167.                        if (brute_moving_state == resolver_moving_start)
  168.                            moving_brute_yaw = slow_walk ? std::uniform_int_distribution<int>(0, 1) (rng) ? -150.0f : 150.0f : 0.0f;
  169.                        
  170.                        if (brute_moving_state == resolver_moving_start_inverse)
  171.                            moving_brute_yaw = std::uniform_int_distribution<int>(0, 1)(rng) ? -167.0f : 167.0f;
  172.                        
  173.                        if (is_moving)
  174.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + moving_brute_yaw;
  175.                        else
  176.                            angle = NormalizeYaw(player->GetAnimState()->goalFeetYaw) + brute_yaw;
  177.                    }
  178.                }
  179.        }
  180.     return angle;
  181. }
  182.  
  183. void FixYaw(const CRecvProxyData *pData, void *pStruct, void *pOut) {
  184.     float flYaw = pData->m_Value.m_Float;
  185.    
  186.     int index = ((C_BaseEntity*)pStruct)->GetIndex();
  187.    
  188.     gCorrections[index].y = flYaw;
  189.    
  190.    
  191.     OldProxy_Y(pData, pStruct, pOut);
  192. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top