Код:
[CODE = cpp]
if (! G_cl.m_lag && g_csgo.m_globals-> m_curtime> = g_cl.m_body_pred && (stand || air) &&! G_input.GetKeyState (g_menu.main.movement.fakewalk.get ())) {
if (! g_aimbot.m_double_tap && stand && g_input.GetKeyState (g_menu.main.antiaim.LBYExploit.get ())) {
g_cl.m_cmd-> m_view_angles.y - = 90.f;
g_cl.m_cmd-> m_tick = INT_MAX;
* g_cl.m_packet = false;
} [/ CODE]
yo its big hacker man b @ $$ and im leaking some shitty shit for 2018 mostly exploits first shrubs big haxor lby break exploit his words not mine luv your shrub <3 minker u 2 fuck loose dox me skid
[CODE = cpp] #include "includes.h"
Resolver g_resolver {} ;;
class AnimationLayer
{
public:
char pad_0000 [20];
uint32_t m_nOrder; // 0x0014
uint32_t m_nSequence; // 0x0018
float_t m_flPrevCycle; // 0x001C
float_t m_flWeight; // 0x0020
float_t m_flWeightDeltaRate; // 0x0024
float_t m_flPlaybackRate; // 0x0028
float_t m_flCycle; // 0x002C
void * m_pOwner; // 0x0030 // player's thisptr
char pad_0038 [4]; // 0x0034
}; // Size: 0x0038
LagRecord * Resolver :: FindIdealRecord (AimPlayer * data) {
LagRecord * first_valid, * current;
if (data-> m_records.empty ())
return nullptr;
first_valid = nullptr;
// iterate records.
for (const auto & it: data-> m_records) {
if (it-> dormant () || it-> immune () ||! it-> valid ())
continue;
// get current record.
current = it.get ();
// first record that was valid, store it for later.
if (! first_valid)
first_valid = current;
// try to find a record with a shot, lby update, walking or no anti-aim.
if (it-> m_shot || it-> m_mode == Modes :: RESOLVE_LAST_LBY || it-> m_mode == Modes :: RESOLVE_WALK || it-> m_mode == Modes :: RESOLVE_NONE)
return current;
}
// none found above, return the first valid record if possible.
return (first_valid)? first_valid: nullptr;
}
LagRecord * Resolver :: FindLastRecord (AimPlayer * data) {
LagRecord * current;
if (data-> m_records.empty ())
return nullptr;
// iterate records in reverse.
for (auto it = data-> m_records.crbegin (); it! = data-> m_records.crend (); ++ it) {
current = it-> get ();
// if this record is valid.
// we are done since we iterated in reverse.
if (current-> valid () &&! current-> immune () &&! current-> dormant ())
return current;
}
return nullptr;
}
void Resolver :: OnBodyUpdate (Player * player, float value) {
AimPlayer * data = & g_aimbot.m_players [player-> index () - 1];
// set data.
data-> m_old_body = data-> m_body;
data-> m_body = value;
}
float Resolver :: GetAwayAngle (LagRecord * record) {
float delta{ std::numeric_limits< float >::max() };
vec3_t pos;
ang_t away;
if (g_cl.m_net_pos.empty()) {
math::VectorAngles(g_cl.m_local->m_vecOrigin() - record->m_pred_origin, away);
return away.y;
}
float owd = (g_cl.m_latency / 2.f);
float target = record->m_pred_time;
// iterate all.
for (const auto& net : g_cl.m_net_pos) {
float dt = std::abs(target - net.m_time);
// the best origin.
if (dt < delta) {
delta = dt;
pos = net.m_pos;
}
}
math::VectorAngles(pos - record->m_pred_origin, away);
return away.y;
}
void Resolver::MatchShot(AimPlayer* data, LagRecord* record) {
// do not attempt to do this in nospread mode.
if (g_menu.main.config.mode.get() == 1)
return;
float shoot_time = -1.f;
Weapon* weapon = data->m_player->GetActiveWeapon();
if (weapon) {
// with logging this time was always one tick behind.
// so add one tick to the last shoot time.
shoot_time = weapon->m_fLastShotTime() + g_csgo.m_globals->m_interval;
}
float delta = game::TIME_TO_TICKS(shoot_time) - game::TIME_TO_TICKS(record->m_sim_time);
// this record has a shot on it.
if (delta == 1)
{
record->m_shot = true;
}
else if (delta == 0)
{
record->m_shot = false;
if (data->m_records.size() >= 2)
{
LagRecord* previous = data->m_records[1].get();
if (previous && !previous->dormant())
record->m_eye_angles.x = previous->m_eye_angles.x;
}
}
}
/*
void Resolver::Override(LagRecord* record)
{
if (!g_input.GetKeyState(g_menu.main.aimbot.override_key.get()))
return;
int cx, cy;
cx = g_cl.m_width / 2;
cy = g_cl.m_height / 2;
vec3_t crosshair = vec3_t(cx, cy, 0);
Player* nearest_player = nullptr;
float bestFoV = 0;
vec2_t bestHead2D, headPos2D;
for (int i = 1; i <= g_csgo.m_globals->m_max_clients; i++) //0 is always the world entity
{
Player* player = g_csgo.m_entlist->GetClientEntity< Player* >(i);
if (!player) //ghetto
continue;
vec3_t headPos3D = record->m_player->GetShootPosition();
if (!render::WorldToScreen(headPos3D, headPos2D))
continue;
float fov = math::GetFOV(g_cl.m_view_angles, g_cl.m_shoot_pos, player->WorldSpaceCenter());
if (fov < bestFoV) {
bestFoV = fov;
nearest_player = player;
bestHead2D = headPos2D;
}
}
if (nearest_player) //use pointers and avoid double calling of GetClientEntity
{
float away = GetAwayAngle(record->);
float new_yaw = NULL;
if ()
float_t new_yaw = yawCorrection;
new_yaw = math::NormalizeYaw(new_yaw);
nearest_player->m_angEyeAngles().y += new_yaw;
}
}
*/
void Resolver::AntiFreestand(LagRecord* record) {
// constants
record->m_resolver_mode = "ANTI FREESTANDING";
constexpr float STEP{ 4.f };
constexpr float RANGE{ 100.f }; // was 32
// best target.
vec3_t enemypos = record->m_player->GetShootPosition();
float away = GetAwayAngle(record);
// construct vector of angles to test.
std::vector< AdaptiveAngle > angles{ };
angles.emplace_back(away - 180.f);
angles.emplace_back(away + 90.f);
angles.emplace_back(away - 90.f);
angles.emplace_back(away + 110.f);
angles.emplace_back(away - 110.f);
// start the trace at the your shoot pos.
vec3_t start = g_cl.m_local->GetShootPosition();
// see if we got any valid result.
// if this is false the path was not obstructed with anything.
bool valid{ false };
// iterate vector of angles.
for (auto it = angles.begin(); it != angles.end(); ++it) {
// compute the 'rough' estimation of where our head will be.
vec3_t end{ enemypos.x + std::cos(math::deg_to_rad(it->m_yaw)) * RANGE,
enemypos.y + std::sin(math::deg_to_rad(it->m_yaw)) * RANGE,
enemypos.z };
// draw a line for debugging purposes.
// g_csgo.m_debug_overlay->AddLineOverlay( start, end, 255, 0, 0, true, 0.1f );
// compute the direction.
vec3_t dir = end - start;
float len = dir.normalize();
// should never happen.
if (len <= 0.f)
continue;
// step thru the total distance, 4 units per step.
for (float i{ 0.f }; i < len; i += STEP) {
// get the current step position.
vec3_t point = start + (dir * i);
// get the contents at this point.
int contents = g_csgo.m_engine_trace->GetPointContents(point, MASK_SHOT_HULL);
// contains nothing that can stop a bullet.
if (!(contents & MASK_SHOT_HULL))
continue;
float mult = 1.f;
if (i < (len * 0.45f)) {
mult = 1.25f;
record->m_eye_angles.y = away - 180.f;
return;
}
// over 50% of the total length, prioritize this shit.
if (i > (len * 0.65f)) // was 0.5f
mult = 1.25f;
// over 90% of the total length, prioritize this shit.
if (i > (len * 0.75f))
mult = 1.25f;
// over 90% of the total length, prioritize this shit.
if (i > (len * 0.9f))
mult = 2.f;
// append 'penetrated distance'.
it->m_dist += (STEP * mult);
// mark that we found anything.
valid = true;
}
}
if (!valid) {
record->m_eye_angles.y = away - 180.f;
return;
}
// put the most distance at the front of the container.
std::sort(angles.begin(), angles.end(),
[](const AdaptiveAngle& a, const AdaptiveAngle& b) {
return a.m_dist > b.m_dist;
});
// the best angle should be at the front now.
AdaptiveAngle* best = &angles.front();
record->m_eye_angles.y = best->m_yaw;
return;
}
void Resolver::SetMode(LagRecord* record) {
float speed = record->m_velocity.length_2d();
if ((record->m_flags & FL_ONGROUND) && speed > 1.f && !record->m_fake_walk) // was added speed < 250.f
record->m_mode = Modes::RESOLVE_WALK;
// if on ground, not moving or fakewalking.
if ((record->m_flags & FL_ONGROUND) && (speed < 1.f || record->m_fake_walk))
record->m_mode = Modes::RESOLVE_STAND;
// if not on ground.
else if (!(record->m_flags & FL_ONGROUND))
record->m_mode = Modes::RESOLVE_AIR;
}
void Resolver::ResolveAngles(Player* player, LagRecord* record) {
AimPlayer* data = &g_aimbot.m_players[player->index() - 1];
// mark this record if it contains a shot.
MatchShot(data, record);
// next up mark this record with a resolver mode that will be used.
SetMode(record);
if (g_menu.main.config.mode.get() == 1)
record->m_eye_angles.x = 90.f;
// we arrived here we can do the acutal resolve.
if (record->m_mode == Modes::RESOLVE_WALK)
ResolveWalk(data, record);
else if (record->m_mode == Modes::RESOLVE_STAND)
//AntiFreestand(record);
ResolveStand(data, record);
else if (record->m_mode == Modes::RESOLVE_AIR)
ResolveAir(data, record);
// normalize the eye angles, doesn't really matter but its clean.
math::NormalizeAngle(record->m_eye_angles.y);
}
void Resolver::ResolveWalk(AimPlayer* data, LagRecord* record) {
// apply lby to eyeangles.
record->m_eye_angles.y = record->m_body;
// delay body update.
data->m_body_update = record->m_anim_time + 0.216f; // was 0.22
// reset stand and body index.
data->m_moving_index = 0;
data->m_stand_index = 0;
data->m_stand_index2 = 0;
data->m_body_index = 0;
data->m_freestanding_index = 0;
record->m_resolver_mode = "ANTI FREESTANDING";
if (data->m_stand_index > 1) {
record->m_mode = Modes::RESOLVE_FREESTAND;
record->m_resolver_mode = "ANTI FREESTANDING CALLED";
AntiFreestand(record);
}
// copy the last record that this player was walking
// we need it later on because it gives us crucial data.
std::memcpy(&data->m_walk_record, record, sizeof(LagRecord));
}
void Resolver::ResolveStand(AimPlayer* data, LagRecord* record) {
// for no-spread call a seperate resolver.
if (g_menu.main.config.mode.get() == 1) {
StandNS(data, record);
return;
}
auto Onetickb4 = (!g_cl.m_lag && g_csgo.m_globals->m_curtime >= g_cl.m_body_pred);
// get predicted away angle for the player.
float away = GetAwayAngle(record);
// pointer for easy access.
LagRecord* move = &data->m_walk_record;
float delta = record->m_anim_time - move->m_anim_time;
// we have a valid moving record.
if (move->m_sim_time > 0.22f && !move->dormant() && !record->dormant()) { // was 0.f
vec3_t delta = move->m_origin - record->m_origin;
// check if moving record is close.
if (delta.length() <= 128.f) { // was 128
// indicate that we are using the moving lby.
data->m_moved = true;
}
}
else
{
record->m_mode = Modes::RESOLVE_FREESTAND;
record->m_resolver_mode = "ANTI FREESTANDING CALLED";
AntiFreestand(record);
}
if (delta < .217f) // can't flick if they moved .22 seconds ago so its just their lby
{
record->m_eye_angles.y = move->m_body;
record->m_mode = Modes::RESOLVE_STOPPED_MOVING;
record->m_resolver_mode = "STOPPED";
}
else if (Onetickb4 == true) {
record->m_eye_angles.y = move->m_body;
data->m_body_update = record->m_anim_time + 1.1f;
record->m_mode = Modes::RESOLVE_LBY_UPDATE;
record->m_resolver_mode = "LBY";
}
else if (data->m_body != data->m_old_body && data->m_body_index <= 5) // flick prediction, has .22 flick predict
{
record->m_eye_angles.y = data->m_body;
data->m_body_update = record->m_anim_time + 1.1f;
record->m_mode = Modes::RESOLVE_LBY_UPDATE;
record->m_resolver_mode = "LBY PRED";
}
else if (data->m_moved && data->m_moving_index < 1) // last moving if we havn't missed it
{
record->m_mode = Modes::RESOLVE_FREESTAND;
record->m_resolver_mode = "ANTI FREESTANDING CALLED";
AntiFreestand(record);
}
else if (!data->m_moved || data->m_moving_index >= 1 && data->m_freestanding_index <= 3) // freestanding if we have gone through that shit or missed last moving
{
record->m_mode = Modes::RESOLVE_FREESTAND;
record->m_resolver_mode = "ANTI FREESTANDING CALLED";
AntiFreestand(record);
}
else // bruteforce as a last fallback
{
switch (data->m_stand_index2 % 4)
{
case 1:
record->m_eye_angles.y = away + 180;
break;
case 2:
record->m_eye_angles.y = away - 110;
break;
case 3:
record->m_eye_angles.y = away + 110;
break;
case 4:
record->m_eye_angles.y = away;
break;
}
record->m_mode = Modes::RESOLVE_BRUTEFORCE;
record->m_resolver_mode = "BRUTEFORCE";
}
}
void Resolver::ResolveAir(AimPlayer* data, LagRecord* record) {
// for no-spread call a seperate resolver.
if (g_menu.main.config.mode.get() == 1) {
AirNS(data, record);
return;
}
// else run our matchmaking air resolver.
if (record->m_velocity.length_2d() < 60.f) {
record->m_mode = Modes::RESOLVE_STAND;
// invoke our stand resolver.
ResolveStand(data, record);
return;
}
// try to predict the direction of the player based on his velocity direction.
// this should be a rough estimation of where he is looking.
float velyaw = math::rad_to_deg(std::atan2(record->m_velocity.y, record->m_velocity.x));
switch (data->m_missed_shots % 3) {
case 0:
record->m_eye_angles.y = velyaw + 180.f;
break;
case 1:
record->m_eye_angles.y = velyaw - 90.f;
break;
case 2:
record->m_eye_angles.y = velyaw + 90.f;
break;
}
record->m_resolver_mode = "AIR";
}
void Resolver::StandNS(AimPlayer* data, LagRecord* record) {
// get away angles.
float away = GetAwayAngle(record);
switch (data->m_shots % 8) {
case 0:
record->m_eye_angles.y = away + 180.f;
break;
case 1:
record->m_eye_angles.y = away + 90.f;
break;
case 2:
record->m_eye_angles.y = away - 90.f;
break;
case 3:
record->m_eye_angles.y = away + 45.f;
break;
case 4:
record->m_eye_angles.y = away - 45.f;
break;
case 5:
record->m_eye_angles.y = away + 135.f;
break;
case 6:
record->m_eye_angles.y = away - 135.f;
break;
case 7:
record->m_eye_angles.y = away + 0.f;
break;
default:
break;
}
// force LBY to not fuck any pose and do a true bruteforce.
record-> m_body = record-> m_eye_angles.y;
}
void Resolver :: AirNS (AimPlayer * data, LagRecord * record) {
// get away angles.
float away = GetAwayAngle (record);
switch (data-> m_missed_shots% 9) {
case 0:
record-> m_eye_angles.y = away + 180.f;
break;
case 1:
record-> m_eye_angles.y = away + 150.f;
break;
case 2:
record-> m_eye_angles.y = away - 150.f;
break;
case 3:
record-> m_eye_angles.y = away + 165.f;
break;
case 4:
record-> m_eye_angles.y = away - 165.f;
break;
case 5:
record-> m_eye_angles.y = away + 135.f;
break;
case 6:
record-> m_eye_angles.y = away - 135.f;
break;
case 7:
record-> m_eye_angles.y = away + 90.f;
break;
case 8:
record-> m_eye_angles.y = away - 90.f;
break;
default:
break;
}
}
void Resolver :: ResolvePoses (Player * player, LagRecord * record) {
AimPlayer * data = & g_aimbot.m_players [player-> index () - 1];
// only do this bs when in air.
if (record-> m_mode == Modes :: RESOLVE_AIR) {
// ang = pose min + pose val x (pose range)
// lean_yaw
player-> m_flPoseParameter () [2] = g_csgo.RandomInt (0, 4) * 0.25f;
// body_yaw
player-> m_flPoseParameter () [11] = g_csgo.RandomInt (1, 3) * 0.25f;
}
} [/ CODE]
big resolver.cpp stainless and popium
[CODE = cpp] void Movement :: cripwalk () {
vec3_t velocity {g_cl.m_local-> m_vecVelocity ()};
int ticks {}, max {16};
if (! g_input.GetKeyState (g_menu.main.movement.cripwalk.get ()))
return;
if (! g_cl.m_local-> GetGroundEntity ())
return;
static int old_cmds = 0;
if (old_cmds! = g_cl.m_cmd-> m_command_number)
old_cmds = g_cl.m_cmd-> m_command_number;
if (* g_cl.m_packet)
{
g_cl.m_cmd-> m_tick = INT_MAX / std :: min ((int) g_menu.main.movement.cripwalkmod.get (), g_cl.m_max_lag);
g_cl.m_cmd-> m_command_number = old_cmds;
}
if (! * g_cl.m_packet)
{
g_cl.m_cmd-> m_tick = old_cmds% 0;
g_cl.m_cmd-> m_command_number = INT_MAX / std :: min ((int) g_menu.main.movement.cripwalkmod.get (), g_cl.m_max_lag);
}
} [/ CODE]
prob the best thing in here it might be shit and bad but i was high and drunk when i made it fuck the kid that leaked half
[CODE=cpp]// popium exploit aa use with micromovements didnt have time to make it so yeah no source
#define shift_ticks INT_MAX
Aimbot g_aimbot{ };;
bool CanFireWithExploit(int m_iShiftedTick)
{
// curtime before shift
float curtime = game::TICKS_TO_TIME(g_cl.m_local->m_nTickBase() - m_iShiftedTick);
return g_cl.CanFireWeapon(curtime);
}
bool Aimbot::CanDT() {
int idx = g_cl.m_weapon->m_iItemDefinitionIndex();
return g_cl.m_local->alive()
&& g_csgo.m_cl->m_choked_commands <= 1
&& m_double_tap && !g_hvh.m_fakeduck;
}
void Aimbot::DoubleTap()
{
static bool did_shift_before = false;
static int double_tapped = 0;
static int prev_shift_ticks = 0;
static bool reset = true;
g_cl.m_tick_to_shift = 0;
if (CanDT())
{
if (m_double_tap)
{
prev_shift_ticks = 0;
auto can_shift_shot = CanFireWithExploit (shift_ticks);
auto can_shot = CanFireWithExploit (abs (-1 - prev_shift_ticks));
if (can_shift_shot ||! can_shot &&! did_shift_before)
{
prev_shift_ticks = shift_ticks;
double_tapped = 0;
}
else {
double_tapped ++;
prev_shift_ticks = 0;
}
if (prev_shift_ticks> 0)
{
if (g_cl.m_weapon-> DTable () && CanFireWithExploit (prev_shift_ticks))
{
if (g_cl.m_cmd-> m_buttons & IN_ATTACK)
{
g_cl.m_tick_to_shift = prev_shift_ticks;
reset = true;
}
else {
if ((! (g_cl.m_cmd-> m_buttons & IN_ATTACK) ||! g_cl.m_shot) && reset
&& fabsf (g_cl.m_weapon-> m_fLastShotTime () - game :: TICKS_TO_TIME (g_cl.m_local-> m_nTickBase ()))> 0.2f) {
g_cl.m_charged = true;
g_cl.m_tick_to_recharge = shift_ticks;
reset = true;
}
}
}
}
did_shift_before = prev_shift_ticks! = 0;
}
}
} [/ CODE]
[CODE = cpp] if (g_aimbot.m_double_tap)
{
if (! g_aimbot.CanDT ())
m_charged = false;
else if (! m_charged && m_tick_to_recharge == 0) {
// m_tick_to_recharge = 13;
m_tick_to_recharge = INT_MAX;
}
}shitty exploit aa just recharging dt with shitty paste like popium, skeet.idb and stainless.fun it would lock the animation
have fun pasting shitty exploits make old hvh bad also fuck waldhack pasting niggers[/CODE]
damn fucked up the code blocks my bad
Последнее редактирование модератором:
