-
Автор темы
- #1
Код:
[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;
}
}have fun pasting shitty exploits make old hvh bad also fuck waldhack pasting niggers[/CODE]
damn fucked up the code blocks my bad
Последнее редактирование модератором:
