Advertisement
Guest User

Untitled

a guest
May 27th, 2018
97
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 28.00 KB | None | 0 0
  1.             //1911
  2.                 else if (actor->IsA(Classes::AWeaponPickup_1911_C::StaticClass()))
  3.                 {
  4.                     if (menu::bItemEsp)
  5.                     {
  6.                         Classes::AWeaponPickup_1911_C* pawn = static_cast<Classes::AWeaponPickup_1911_C*>(actor);
  7.                         if (pawn == nullptr)
  8.                             continue;
  9.  
  10.                         if (pawn->RootComponent == nullptr)
  11.                             continue;
  12.  
  13.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  14.                         Classes::FVector2D screenPos;
  15.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  16.                         if (screenPos.X == 0 && screenPos.Y == 0)
  17.                             continue;
  18.  
  19.  
  20.                         // Get Distance
  21.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  22.                         std::wstring distanceText = Util::DistanceToString(distance);
  23.                         if (distance < 150.0f)
  24.                         {
  25.                             // Draw Distance
  26.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  27.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"1911 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  28.                         }
  29.                     }
  30.                 }
  31.                 else if (actor->IsA(Classes::AWeaponPickup_1887_C::StaticClass()))
  32.                 {
  33.                     if (menu::bItemEsp)
  34.                     {
  35.                         Classes::AWeaponPickup_1887_C* pawn = static_cast<Classes::AWeaponPickup_1887_C*>(actor);
  36.                         if (pawn == nullptr)
  37.                             continue;
  38.  
  39.                         if (pawn->RootComponent == nullptr)
  40.                             continue;
  41.  
  42.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  43.                         Classes::FVector2D screenPos;
  44.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  45.                         if (screenPos.X == 0 && screenPos.Y == 0)
  46.                             continue;
  47.  
  48.  
  49.                         // Get Distance
  50.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  51.                         std::wstring distanceText = Util::DistanceToString(distance);
  52.                         if (distance < 150.0f)
  53.                         {
  54.                             // Draw Distance
  55.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  56.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"1887 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  57.                         }
  58.                     }
  59.                 }
  60.                 else if (actor->IsA(Classes::AWeaponPickup_fal_C::StaticClass()))
  61.                 {
  62.                     if (menu::bItemEsp)
  63.                     {
  64.                         Classes::AWeaponPickup_fal_C* pawn = static_cast<Classes::AWeaponPickup_fal_C*>(actor);
  65.                         if (pawn == nullptr)
  66.                             continue;
  67.  
  68.                         if (pawn->RootComponent == nullptr)
  69.                             continue;
  70.  
  71.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  72.                         Classes::FVector2D screenPos;
  73.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  74.                         if (screenPos.X == 0 && screenPos.Y == 0)
  75.                             continue;
  76.  
  77.  
  78.                         // Get Distance
  79.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  80.                         std::wstring distanceText = Util::DistanceToString(distance);
  81.                         if (distance < 150.0f)
  82.                         {
  83.                             // Draw Distance
  84.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  85.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"FAL [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  86.                         }
  87.                     }
  88.                 }
  89.  
  90.                 else if (actor->IsA(Classes::AWeaponPickup_dragunov_C::StaticClass()))
  91.                 {
  92.                     if (menu::bItemEsp)
  93.                     {
  94.                         Classes::AWeaponPickup_dragunov_C* pawn = static_cast<Classes::AWeaponPickup_dragunov_C*>(actor);
  95.                         if (pawn == nullptr)
  96.                             continue;
  97.  
  98.                         if (pawn->RootComponent == nullptr)
  99.                             continue;
  100.  
  101.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  102.                         Classes::FVector2D screenPos;
  103.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  104.                         if (screenPos.X == 0 && screenPos.Y == 0)
  105.                             continue;
  106.  
  107.  
  108.                         // Get Distance
  109.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  110.                         std::wstring distanceText = Util::DistanceToString(distance);
  111.                         if (distance < 150.0f)
  112.                         {
  113.                             // Draw Distance
  114.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  115.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"FAL [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  116.                         }
  117.                     }
  118.                 }
  119.  
  120.                 else if (actor->IsA(Classes::AWeaponPickup_hitec_C::StaticClass()))
  121.                 {
  122.                     if (menu::bItemEsp)
  123.                     {
  124.                         Classes::AWeaponPickup_hitec_C* pawn = static_cast<Classes::AWeaponPickup_hitec_C*>(actor);
  125.                         if (pawn == nullptr)
  126.                             continue;
  127.  
  128.                         if (pawn->RootComponent == nullptr)
  129.                             continue;
  130.  
  131.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  132.                         Classes::FVector2D screenPos;
  133.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  134.                         if (screenPos.X == 0 && screenPos.Y == 0)
  135.                             continue;
  136.  
  137.  
  138.                         // Get Distance
  139.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  140.                         std::wstring distanceText = Util::DistanceToString(distance);
  141.                         if (distance < 150.0f)
  142.                         {
  143.                             // Draw Distance
  144.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  145.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"UZI 9mm [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  146.                         }
  147.                     }
  148.                 }
  149.                 else if (actor->IsA(Classes::AWeaponPickup_m14_C::StaticClass()))
  150.                 {
  151.                     if (menu::bItemEsp)
  152.                     {
  153.                         Classes::AWeaponPickup_m14_C* pawn = static_cast<Classes::AWeaponPickup_m14_C*>(actor);
  154.                         if (pawn == nullptr)
  155.                             continue;
  156.  
  157.                         if (pawn->RootComponent == nullptr)
  158.                             continue;
  159.  
  160.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  161.                         Classes::FVector2D screenPos;
  162.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  163.                         if (screenPos.X == 0 && screenPos.Y == 0)
  164.                             continue;
  165.  
  166.  
  167.                         // Get Distance
  168.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  169.                         std::wstring distanceText = Util::DistanceToString(distance);
  170.                         if (distance < 150.0f)
  171.                         {
  172.                             // Draw Distance
  173.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  174.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"M14 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  175.                         }
  176.                     }
  177.                 }
  178.                 else if (actor->IsA(Classes::AWeaponPickup_m12_C::StaticClass()))
  179.                 {
  180.                     if (menu::bItemEsp)
  181.                     {
  182.                         Classes::AWeaponPickup_m12_C* pawn = static_cast<Classes::AWeaponPickup_m12_C*>(actor);
  183.                         if (pawn == nullptr)
  184.                             continue;
  185.  
  186.                         if (pawn->RootComponent == nullptr)
  187.                             continue;
  188.  
  189.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  190.                         Classes::FVector2D screenPos;
  191.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  192.                         if (screenPos.X == 0 && screenPos.Y == 0)
  193.                             continue;
  194.  
  195.  
  196.                         // Get Distance
  197.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  198.                         std::wstring distanceText = Util::DistanceToString(distance);
  199.                         if (distance < 150.0f)
  200.                         {
  201.                             // Draw Distance
  202.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  203.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"M12 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  204.                         }
  205.                     }
  206.                 }
  207.  
  208.                 else if (actor->IsA(Classes::AWeaponPickup_M16_C::StaticClass()))
  209.                 {
  210.                     if (menu::bItemEsp)
  211.                     {
  212.                         Classes::AWeaponPickup_M16_C* pawn = static_cast<Classes::AWeaponPickup_M16_C*>(actor);
  213.                         if (pawn == nullptr)
  214.                             continue;
  215.  
  216.                         if (pawn->RootComponent == nullptr)
  217.                             continue;
  218.  
  219.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  220.                         Classes::FVector2D screenPos;
  221.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  222.                         if (screenPos.X == 0 && screenPos.Y == 0)
  223.                             continue;
  224.  
  225.  
  226.                         // Get Distance
  227.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  228.                         std::wstring distanceText = Util::DistanceToString(distance);
  229.                         if (distance < 150.0f)
  230.                         {
  231.                             // Draw Distance
  232.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  233.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"M16 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  234.                         }
  235.                     }
  236.                 }
  237.  
  238.                 else if (actor->IsA(Classes::AWeaponPickup_hipower_C::StaticClass()))
  239.                 {
  240.                     if (menu::bItemEsp)
  241.                     {
  242.                         Classes::AWeaponPickup_hipower_C* pawn = static_cast<Classes::AWeaponPickup_hipower_C*>(actor);
  243.                         if (pawn == nullptr)
  244.                             continue;
  245.  
  246.                         if (pawn->RootComponent == nullptr)
  247.                             continue;
  248.  
  249.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  250.                         Classes::FVector2D screenPos;
  251.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  252.                         if (screenPos.X == 0 && screenPos.Y == 0)
  253.                             continue;
  254.  
  255.  
  256.                         // Get Distance
  257.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  258.                         std::wstring distanceText = Util::DistanceToString(distance);
  259.                         if (distance < 150.0f)
  260.                         {
  261.                             // Draw Distance
  262.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  263.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"HiPower Pistol [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  264.                         }
  265.                     }
  266.                 }
  267.                 else if (actor->IsA(Classes::AWeaponPickup_python_C::StaticClass()))
  268.                 {
  269.                     if (menu::bItemEsp)
  270.                     {
  271.                         Classes::AWeaponPickup_python_C* pawn = static_cast<Classes::AWeaponPickup_python_C*>(actor);
  272.                         if (pawn == nullptr)
  273.                             continue;
  274.  
  275.                         if (pawn->RootComponent == nullptr)
  276.                             continue;
  277.  
  278.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  279.                         Classes::FVector2D screenPos;
  280.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  281.                         if (screenPos.X == 0 && screenPos.Y == 0)
  282.                             continue;
  283.  
  284.  
  285.                         // Get Distance
  286.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  287.                         std::wstring distanceText = Util::DistanceToString(distance);
  288.                         if (distance < 150.0f)
  289.                         {
  290.                             // Draw Distance
  291.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  292.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Python [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  293.                         }
  294.                     }
  295.                 }
  296.                 else if (actor->IsA(Classes::AWeaponPickup_python_C::StaticClass()))
  297.                 {
  298.                     if (menu::bItemEsp)
  299.                     {
  300.                         Classes::AWeaponPickup_python_C* pawn = static_cast<Classes::AWeaponPickup_python_C*>(actor);
  301.                         if (pawn == nullptr)
  302.                             continue;
  303.  
  304.                         if (pawn->RootComponent == nullptr)
  305.                             continue;
  306.  
  307.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  308.                         Classes::FVector2D screenPos;
  309.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  310.                         if (screenPos.X == 0 && screenPos.Y == 0)
  311.                             continue;
  312.  
  313.  
  314.                         // Get Distance
  315.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  316.                         std::wstring distanceText = Util::DistanceToString(distance);
  317.                         if (distance < 150.0f)
  318.                         {
  319.                             // Draw Distance
  320.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  321.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Python [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  322.                         }
  323.                     }
  324.                 }
  325.  
  326.                 else if (actor->IsA(Classes::AWeaponPickup_RX_C::StaticClass()))
  327.                 {
  328.                     if (menu::bItemEsp)
  329.                     {
  330.                         Classes::AWeaponPickup_RX_C* pawn = static_cast<Classes::AWeaponPickup_RX_C*>(actor);
  331.                         if (pawn == nullptr)
  332.                             continue;
  333.  
  334.                         if (pawn->RootComponent == nullptr)
  335.                             continue;
  336.  
  337.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  338.                         Classes::FVector2D screenPos;
  339.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  340.                         if (screenPos.X == 0 && screenPos.Y == 0)
  341.                             continue;
  342.  
  343.  
  344.                         // Get Distance
  345.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  346.                         std::wstring distanceText = Util::DistanceToString(distance);
  347.                         if (distance < 150.0f)
  348.                         {
  349.                             // Draw Distance
  350.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  351.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"C4 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  352.                         }
  353.                     }
  354.                 }
  355.                 else if (actor->IsA(Classes::AWeaponPickup_ppk_C::StaticClass()))
  356.                 {
  357.                     if (menu::bItemEsp)
  358.                     {
  359.                         Classes::AWeaponPickup_ppk_C* pawn = static_cast<Classes::AWeaponPickup_ppk_C*>(actor);
  360.                         if (pawn == nullptr)
  361.                             continue;
  362.  
  363.                         if (pawn->RootComponent == nullptr)
  364.                             continue;
  365.  
  366.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  367.                         Classes::FVector2D screenPos;
  368.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  369.                         if (screenPos.X == 0 && screenPos.Y == 0)
  370.                             continue;
  371.  
  372.  
  373.                         // Get Distance
  374.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  375.                         std::wstring distanceText = Util::DistanceToString(distance);
  376.                         if (distance < 150.0f)
  377.                         {
  378.                             // Draw Distance
  379.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  380.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"PPK [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  381.                         }
  382.                     }
  383.                 }
  384.  
  385.                 else if (actor->IsA(Classes::AWeaponPickup_RocketLauncher_C::StaticClass()))
  386.                 {
  387.                     if (menu::bItemEsp)
  388.                     {
  389.                         Classes::AWeaponPickup_RocketLauncher_C* pawn = static_cast<Classes::AWeaponPickup_RocketLauncher_C*>(actor);
  390.                         if (pawn == nullptr)
  391.                             continue;
  392.  
  393.                         if (pawn->RootComponent == nullptr)
  394.                             continue;
  395.  
  396.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  397.                         Classes::FVector2D screenPos;
  398.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  399.                         if (screenPos.X == 0 && screenPos.Y == 0)
  400.                             continue;
  401.  
  402.  
  403.                         // Get Distance
  404.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  405.                         std::wstring distanceText = Util::DistanceToString(distance);
  406.                         if (distance < 150.0f)
  407.                         {
  408.                             // Draw Distance
  409.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  410.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Rocket Launcher [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  411.                         }
  412.                     }
  413.                 }
  414.  
  415.                 else if (actor->IsA(Classes::AConsumablePickup_Medkit3_C::StaticClass()))
  416.                 {
  417.                     if (menu::bItemEsp)
  418.                     {
  419.                         Classes::AConsumablePickup_Medkit3_C* pawn = static_cast<Classes::AConsumablePickup_Medkit3_C*>(actor);
  420.                         if (pawn == nullptr)
  421.                             continue;
  422.  
  423.                         if (pawn->RootComponent == nullptr)
  424.                             continue;
  425.  
  426.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  427.                         Classes::FVector2D screenPos;
  428.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  429.                         if (screenPos.X == 0 && screenPos.Y == 0)
  430.                             continue;
  431.  
  432.  
  433.                         // Get Distance
  434.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  435.                         std::wstring distanceText = Util::DistanceToString(distance);
  436.                         if (distance < 150.0f)
  437.                         {
  438.                             // Draw Distance
  439.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  440.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"MedKit3 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  441.                         }
  442.                     }
  443.                 }
  444.                 else if (actor->IsA(Classes::AConsumablePickup_Medkit_C::StaticClass()))
  445.                 {
  446.                     if (menu::bItemEsp)
  447.                     {
  448.                         Classes::AConsumablePickup_Medkit_C* pawn = static_cast<Classes::AConsumablePickup_Medkit_C*>(actor);
  449.                         if (pawn == nullptr)
  450.                             continue;
  451.  
  452.                         if (pawn->RootComponent == nullptr)
  453.                             continue;
  454.  
  455.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  456.                         Classes::FVector2D screenPos;
  457.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  458.                         if (screenPos.X == 0 && screenPos.Y == 0)
  459.                             continue;
  460.  
  461.  
  462.                         // Get Distance
  463.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  464.                         std::wstring distanceText = Util::DistanceToString(distance);
  465.                         if (distance < 150.0f)
  466.                         {
  467.                             // Draw Distance
  468.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  469.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"MedKit [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  470.                         }
  471.                     }
  472.                 }
  473.  
  474.                 else if (actor->IsA(Classes::AConsumable_Burger_C::StaticClass()))
  475.                 {
  476.                     if (menu::bItemEsp)
  477.                     {
  478.                         Classes::AConsumable_Burger_C* pawn = static_cast<Classes::AConsumable_Burger_C*>(actor);
  479.                         if (pawn == nullptr)
  480.                             continue;
  481.  
  482.                         if (pawn->RootComponent == nullptr)
  483.                             continue;
  484.  
  485.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  486.                         Classes::FVector2D screenPos;
  487.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  488.                         if (screenPos.X == 0 && screenPos.Y == 0)
  489.                             continue;
  490.  
  491.  
  492.                         // Get Distance
  493.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  494.                         std::wstring distanceText = Util::DistanceToString(distance);
  495.                         if (distance < 150.0f)
  496.                         {
  497.                             // Draw Distance
  498.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  499.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Burger [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  500.                         }
  501.                     }
  502.                 }
  503.                 else if (actor->IsA(Classes::AArmorPickup_Body_Light_C::StaticClass()))
  504.                 {
  505.                     if (menu::bItemEsp)
  506.                     {
  507.                         Classes::AArmorPickup_Body_Light_C* pawn = static_cast<Classes::AArmorPickup_Body_Light_C*>(actor);
  508.                         if (pawn == nullptr)
  509.                             continue;
  510.  
  511.                         if (pawn->RootComponent == nullptr)
  512.                             continue;
  513.  
  514.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  515.                         Classes::FVector2D screenPos;
  516.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  517.                         if (screenPos.X == 0 && screenPos.Y == 0)
  518.                             continue;
  519.  
  520.  
  521.                         // Get Distance
  522.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  523.                         std::wstring distanceText = Util::DistanceToString(distance);
  524.                         if (distance < 150.0f)
  525.                         {
  526.                             // Draw Distance
  527.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  528.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Light Armor [" + distanceText + L"]", BLACK_COLOR, 0, FONT_SIZE, FONT_TYPE);
  529.                         }
  530.                     }
  531.                 }
  532.  
  533.                 else if (actor->IsA(Classes::AArmorPickup_Body_Medium_C::StaticClass()))
  534.                 {
  535.                     if (menu::bItemEsp)
  536.                     {
  537.                         Classes::AArmorPickup_Body_Medium_C* pawn = static_cast<Classes::AArmorPickup_Body_Medium_C*>(actor);
  538.                         if (pawn == nullptr)
  539.                             continue;
  540.  
  541.                         if (pawn->RootComponent == nullptr)
  542.                             continue;
  543.  
  544.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  545.                         Classes::FVector2D screenPos;
  546.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  547.                         if (screenPos.X == 0 && screenPos.Y == 0)
  548.                             continue;
  549.  
  550.  
  551.                         // Get Distance
  552.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  553.                         std::wstring distanceText = Util::DistanceToString(distance);
  554.                         if (distance < 150.0f)
  555.                         {
  556.                             // Draw Distance
  557.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  558.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Medium Armor [" + distanceText + L"]", BLACK_COLOR, 0, FONT_SIZE, FONT_TYPE);
  559.                         }
  560.                     }
  561.                 }
  562.  
  563.                 else if (actor->IsA(Classes::AArmorPickup_Body_Heavy_C::StaticClass()))
  564.                 {
  565.                     if (menu::bItemEsp)
  566.                     {
  567.                         Classes::AArmorPickup_Body_Heavy_C* pawn = static_cast<Classes::AArmorPickup_Body_Heavy_C*>(actor);
  568.                         if (pawn == nullptr)
  569.                             continue;
  570.  
  571.                         if (pawn->RootComponent == nullptr)
  572.                             continue;
  573.  
  574.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  575.                         Classes::FVector2D screenPos;
  576.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  577.                         if (screenPos.X == 0 && screenPos.Y == 0)
  578.                             continue;
  579.  
  580.  
  581.                         // Get Distance
  582.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  583.                         std::wstring distanceText = Util::DistanceToString(distance);
  584.                         if (distance < 150.0f)
  585.                         {
  586.                             // Draw Distance
  587.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  588.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Heavy Armor [" + distanceText + L"]", BLACK_COLOR, 0, FONT_SIZE, FONT_TYPE);
  589.                         }
  590.                     }
  591.                 }
  592.                 else if (actor->IsA(Classes::AArmorPickup_Body_Special_C::StaticClass()))
  593.                 {
  594.                     if (menu::bItemEsp)
  595.                     {
  596.                         Classes::AArmorPickup_Body_Special_C* pawn = static_cast<Classes::AArmorPickup_Body_Special_C*>(actor);
  597.                         if (pawn == nullptr)
  598.                             continue;
  599.  
  600.                         if (pawn->RootComponent == nullptr)
  601.                             continue;
  602.  
  603.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  604.                         Classes::FVector2D screenPos;
  605.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  606.                         if (screenPos.X == 0 && screenPos.Y == 0)
  607.                             continue;
  608.  
  609.  
  610.                         // Get Distance
  611.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  612.                         std::wstring distanceText = Util::DistanceToString(distance);
  613.                         if (distance < 150.0f)
  614.                         {
  615.                             // Draw Distance
  616.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  617.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"Special Armor [" + distanceText + L"]", BLACK_COLOR, 0, FONT_SIZE, FONT_TYPE);
  618.                         }
  619.                     }
  620.                 }
  621.                 else if (actor->IsA(Classes::AAmmoPickup_223_C::StaticClass()))
  622.                 {
  623.                     if (menu::bItemEsp)
  624.                     {
  625.                         Classes::AAmmoPickup_223_C* pawn = static_cast<Classes::AAmmoPickup_223_C*>(actor);
  626.                         if (pawn == nullptr)
  627.                             continue;
  628.  
  629.                         if (pawn->RootComponent == nullptr)
  630.                             continue;
  631.  
  632.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  633.                         Classes::FVector2D screenPos;
  634.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  635.                         if (screenPos.X == 0 && screenPos.Y == 0)
  636.                             continue;
  637.  
  638.  
  639.                         // Get Distance
  640.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  641.                         std::wstring distanceText = Util::DistanceToString(distance);
  642.                         if (distance < 150.0f)
  643.                         {
  644.                             // Draw Distance
  645.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  646.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"AMMO 223 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  647.                         }
  648.                     }
  649.                 }
  650.                 else if (actor->IsA(Classes::AAmmoPickup_9_C::StaticClass()))
  651.                 {
  652.                     if (menu::bItemEsp)
  653.                     {
  654.                         Classes::AAmmoPickup_9_C* pawn = static_cast<Classes::AAmmoPickup_9_C*>(actor);
  655.                         if (pawn == nullptr)
  656.                             continue;
  657.  
  658.                         if (pawn->RootComponent == nullptr)
  659.                             continue;
  660.  
  661.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  662.                         Classes::FVector2D screenPos;
  663.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  664.                         if (screenPos.X == 0 && screenPos.Y == 0)
  665.                             continue;
  666.  
  667.  
  668.                         // Get Distance
  669.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  670.                         std::wstring distanceText = Util::DistanceToString(distance);
  671.                         if (distance < 150.0f)
  672.                         {
  673.  
  674.                             // Draw Distance
  675.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  676.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"AMMO 9mm [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  677.                         }
  678.                     }
  679.                 }
  680.                 else if (actor->IsA(Classes::AAmmoPickup_45_C::StaticClass()))
  681.                 {
  682.                     if (menu::bItemEsp)
  683.                     {
  684.                         Classes::AAmmoPickup_45_C* pawn = static_cast<Classes::AAmmoPickup_45_C*>(actor);
  685.                         if (pawn == nullptr)
  686.                             continue;
  687.  
  688.                         if (pawn->RootComponent == nullptr)
  689.                             continue;
  690.  
  691.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  692.                         Classes::FVector2D screenPos;
  693.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  694.                         if (screenPos.X == 0 && screenPos.Y == 0)
  695.                             continue;
  696.  
  697.  
  698.                         // Get Distance
  699.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  700.                         std::wstring distanceText = Util::DistanceToString(distance);
  701.                         if (distance < 150.0f)
  702.                         {
  703.                             // Draw Distance
  704.                             Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  705.                             renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"AMMO .45 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  706.                         }
  707.                     }
  708.                 }
  709.  
  710.                 else if (actor->IsA(Classes::AAmmoPickup_308_C::StaticClass()))
  711.                 {
  712.                     if (menu::bItemEsp)
  713.                     {
  714.                         Classes::AAmmoPickup_308_C* pawn = static_cast<Classes::AAmmoPickup_308_C*>(actor);
  715.                         if (pawn == nullptr)
  716.                             continue;
  717.  
  718.                         if (pawn->RootComponent == nullptr)
  719.                             continue;
  720.  
  721.                         Classes::FVector pos = pawn->RootComponent->RelativeLocation;
  722.                         Classes::FVector2D screenPos;
  723.                         Global::m_LocalPlayer->PlayerController->ProjectWorldLocationToScreen(pos, &screenPos);
  724.                         if (screenPos.X == 0 && screenPos.Y == 0)
  725.                             continue;
  726.  
  727.  
  728.                         // Get Distance
  729.                         float distance = Util::GetDistance(Global::m_LocalPlayer->PlayerController->AcknowledgedPawn->RootComponent->RelativeLocation, pos);
  730.  
  731.                         if (distance < 150.0f)
  732.                         {
  733.                         std::wstring distanceText = Util::DistanceToString(distance);
  734.  
  735.                         // Draw Distance
  736.                         Vec2 size = renderer->getTextExtent(distanceText, FONT_SIZE, FONT_TYPE);
  737.                         renderer->drawText(Vec2(screenPos.X - size.x / 2, screenPos.Y), L"AMMO .308 [" + distanceText + L"]", WHITE_COLOR, 0, FONT_SIZE, FONT_TYPE);
  738.                         }
  739.                     }
  740.                 }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement