good morning people new release
today we are releasing pxnch's desync
was planning to make this code public but i had some stuff going on
s/o simon freese(pxnch), andre(vega), puzzlepirate(rome the pedo, s/o exitscambot), errera (una, free spoonfeed for pxnch), claude and deepseek
ps: nice update pxnch, broke the entire hack btw LOL
note:
this code was sloppified purposefully to not be copy paste ready
this was btw spoonfed from rome/errera to pxnch, this is straight up Get Banned from moneybot hello @rome, hows grooming kids going along?
ive also removed the fakelag and the rest of the antiaim along with adding one feature or two to the desync (happy pasting)
for any other inquiries dm on forums
and for anyone still paying for pxnch's dogshit, reconsider your life choices
C++:
i
struct Band { float pos = 0.f, neg = 0.f, width = 1.f; };
struct CPredictedAnimstate {
bool ok = false;
float foot_yaw = 0.f;
};
struct FakeAnim {
CCSGOPlayerAnimState state{ };
C_AnimationLayers layers{ };
float poses[ 24 ]{ };
float lby = 0.f;
float foot_yaw = 0.f;
bool valid = false;
bool srv_jumping = false;
float srv_realign_timer = 0.f;
bool srv_deploy_limit = false;
float srv_lby = 0.f;
ActModifiers srv_act_mods{ };
};
inline FakeAnim g_FakeAnims{ };
struct CAnimBackup {
CCSGOPlayerAnimState state{ };
C_AnimationLayers layers{ };
float poses[ 24 ]{ };
float lby = 0.f;
bool valid = false;
bool srv_valid = false;
bool srv_jumping = false;
float srv_realign_timer = 0.f;
bool srv_realign_moving = false;
bool srv_deploy_limit = false;
float srv_lby = 0.f;
ActModifiers srv_act_mods{ };
};
inline void AnimationStateRestore( CAnimBackup& ctx, Player* p ) {
if( ctx.srv_valid ) {
if( CCSGOPlayerAnimState_ServerSim* srv = GetServerAnim( p ) ) {
srv->m_jumping = ctx.srv_jumping;
srv->m_realign_timer = ctx.srv_realign_timer;
srv->m_realign_moving = ctx.srv_realign_moving;
srv->m_deploy_limiting = ctx.srv_deploy_limit;
srv->m_lby = ctx.srv_lby;
srv->m_act_mods = ctx.srv_act_mods;
}
}
if( SnapshotRestore( p ) )
return;
CCSGOPlayerAnimState* as = ctx.valid ? GetAnimState( p ) : nullptr;
if( !as )
return;
std::memcpy( as, &ctx.state, sizeof( CCSGOPlayerAnimState ) );
SetLayers( p, ctx.layers );
SetPoses ( p, ctx.poses );
*LowerBodyYaw( p ) = ctx.lby;
}
inline CPredictedAnimstate PredictAnimationState( CAnimBackup& ctx, Player* p,
float cand_yaw, float probe_time ) {
CPredictedAnimstate out;
if( !ctx.valid )
return out;
CCSGOPlayerAnimState* as = GetAnimState( p );
if( !as )
return out;
AnimationStateRestore( ctx, p );
ApplyClock( probe_time, Interval( ) );
as->m_nLastUpdateFrame--;
// not mercury, tells the hack its a partial update, not a full one
// you only need SetUpAimMatrix and SetUpVelocity
CCSGOPlayerAnimstate_Update( as, math::NormalizedAngle( cand_yaw ), m_pitch_out, true, false );
out.ok = as->m_flLastUpdateIncrement > 0.f;
out.foot_yaw = as->m_flFootYaw;
RestoreClock( );
return out;
}
inline void StoreLastAnimstate( Player* local ) {
CCSGOPlayerAnimState* as = ( local && GetAnimState ) ? GetAnimState( local ) : nullptr;
if( !as )
return;
std::memcpy( &m_last_animstate, as, sizeof( CCSGOPlayerAnimState ) );
m_last_animstate_valid = true;
}
inline bool ApplyLastFake( Cmd& c, Player* me ) {
if( g_ctx.choked == 0 )
return false;
if( *c.buttons & IN_USE )
return false;
*c.yaw = *LowerBodyYaw( me );
return true;
}
inline void ClampVelocity( Cmd& c, Player* me, float target ) {
const vec3_t vel = Velocity( me );
float vx = vel.x, vy = vel.y;
float budget = CS_PLAYER_SPEED_RUN;
{
const float wmax = MaxWeaponSpeed( me );
if( wmax > 0.f && wmax < budget )
budget = wmax;
}
const bool on_ground = ( Flags( me ) & FL_ONGROUND ) != 0;
if( on_ground )
budget *= VelocityModifier( me );
const float stamina = Stamina( me );
if( stamina > 0.f ) {
float t = stamina / -100.f + 1.f;
math::clamp( t, 0.f, 1.f );
budget *= t * t;
}
*c.buttons &= ~IN_SPEED;
const float surface = SurfaceFriction( me );
const float dt = Interval( );
if( on_ground ) {
const float mag = std::sqrt( vx * vx + vy * vy );
if( mag >= 0.1f ) {
const float control = mag < g_ctx.sv_stopspeed ? g_ctx.sv_stopspeed : mag;
const float drop = g_ctx.sv_friction * surface * control * dt;
float newspeed = mag - drop;
if( newspeed < 0.f )
newspeed = 0.f;
if( newspeed != mag ) {
const float ratio = newspeed / mag;
vx *= ratio;
vy *= ratio;
}
}
}
const float mag = std::sqrt( vx * vx + vy * vy );
if( target >= mag ) {
float fwd = *c.forward;
float side = *c.side;
const float cur = std::sqrt( fwd * fwd + side * side );
if( target <= 0.1f || cur <= 0.1f ) {
fwd = side = 0.f;
}
else {
fwd = fwd / cur * target;
side = side / cur * target;
}
*c.forward = fwd;
*c.side = side;
RePredictMovement( c.raw );
return;
}
const float vel_yaw = ( vx == 0.f && vy == 0.f )
? 90.f
: math::rad_to_deg( std::atan2( -vy, -vx ) );
const float delta = math::deg_to_rad( *c.yaw - vel_yaw );
float fwd_dir = std::cos( delta );
float side_dir = std::sin( delta );
{
const float len = std::sqrt( fwd_dir * fwd_dir + side_dir * side_dir + 1e-10f );
fwd_dir /= len;
side_dir /= len;
}
float scale;
if( on_ground ) {
scale = mag - target;
}
else {
const float accel = g_ctx.sv_airaccelerate * dt * surface;
scale = accel != 0.f ? ( mag - target ) / accel : 0.f;
if( scale > budget )
scale = budget;
}
*c.forward = fwd_dir * scale;
*c.side = side_dir * scale;
RePredictMovement( c.raw );
}
inline void RunDesync( Cmd& c, Player* me, const Band& band,
float sim_foot, float real_yaw, CAnimBackup& ctx ) {
const float entry_dir = *c.yaw;
if( m_mode == AIR ) {
ApplyLastFake( c, me );
return;
}
m_desync_engaged = m_desync_engaged && ( m_mode == WALK );
if( !g_cfg.desync ) {
m_desync_engaged = false;
ApplyLastFake( c, me );
return;
}
CCSGOPlayerAnimState* state = GetAnimState( me );
{
const float air = m_pre_probe_valid ? m_pre_probe_air
: ( state ? state->m_flDurationInAir : 0.f );
if( air > 0.f )
m_desync_engaged = false;
}
const bool ground_pre = m_pre_probe_valid ? m_pre_probe_ground : ( state && state->m_bOnGround );
const float rec_speed = m_pre_probe_valid ? m_pre_probe_speed
: ( state ? state->m_flVelocityLengthXY : 0.f );
{
const float speed = Velocity( me ).length_2d( );
const bool tf_edge = ( speed > 0.1f )
&& ( Flags( me ) & FL_ONGROUND )
&& !( *c.buttons & IN_JUMP )
&& ( rec_speed <= 0.1f || !ground_pre ); // stand2walk and jump2walk
if( tf_edge && !m_trans_flick_done )
m_trans_flick_pending = true;
if( !tf_edge && ( g_ctx.lag == 0 ) )
m_trans_flick_done = false;
m_trans_flick_arm = m_trans_flick_pending && ( g_ctx.lag == 0 ); // only arm on animation tick
}
if( ( g_cfg.trans_flick || g_cfg.extend_desync )
&& m_trans_flick_arm && !m_trans_flick_done && state && g_FakeAnims.valid ) { // not mercury, needed for normal twist
const float t_real = m_pre_probe_valid ? m_pre_probe_foot : state->m_flFootYaw;
const float t_mid = t_real + math::AngleDiff( g_FakeAnims.foot_yaw, t_real ) * 0.5f;
*c.yaw = math::NormalizedAngle( t_mid + 180.f );
m_trans_flick_pending = false;
m_trans_flick_done = true;
m_trans_flick_cmd = c.number;
m_choke_target = 2;
if( g_cfg.extend_desync && g_ctx.avoid_autostop )
*c.forward = *c.side = 0.f;
return;
}
// note: not mercury, mercury does not have a transition flick
// their twist also does not work full on rely on the sole fact of them not resolving you properly
if( g_cfg.extend_desync ) { // fix transition flick breaking extended
const int since_flick = std::abs( m_trans_flick_cmd - c.number );
if( since_flick < 8 ) { // let our flick settle
if( since_flick < 3 && g_ctx.avoid_autostop ) // let friction slow us down rq
*c.forward = *c.side = 0.f;
m_choke_target = 2; // could be 1
return;
}
}
// dont do jack we arent desyncing
const bool was_moving = m_pre_probe_valid ? ( m_pre_probe_speed > 0.1f )
: ( state && state->m_flVelocityLengthXY > 0.1f );
if( !was_moving || !ground_pre )
return;
if( m_mode != WALK || !state || !g_FakeAnims.valid )
return;
const float rec_foot = m_pre_probe_valid ? m_pre_probe_foot : state->m_flFootYaw;
const float fake_foot = g_FakeAnims.foot_yaw;
if( std::abs( math::NormalizedAngle( rec_foot - fake_foot ) ) < 10.f ) {
m_flick_fired = false;
m_desync_engaged = false;
ApplyLastFake( c, me );
// bug: probably should be an else here, dont know, dont care
if( g_cfg.keep_desync
&& std::abs( math::NormalizedAngle( *c.yaw - m_last_sent_yaw ) ) < 10.f ) {
m_flick_fired = false;
m_desync_engaged = false;
}
// unengage desync here? maybe, dont know, didnt test
return;
}
if( !g_cfg.keep_desync || g_ctx.lag != 0 ) { // also bugged i believe, owell
ApplyLastFake( c, me );
if( g_cfg.keep_desync
&& std::abs( math::NormalizedAngle( *c.yaw - m_last_sent_yaw ) ) < 10.f ) {
m_flick_fired = false;
m_desync_engaged = false;
}
return;
}
{
float e = math::AngleDiff( sim_foot, real_yaw );
if( e > band.pos ) e = band.pos;
if( e < band.neg ) e = band.neg;
m_choke_target = 1;
}
if( m_flick_fired ) {
m_flick_fired = false;
return;
}
if( g_cfg.extend_desync /*&& !( *c.buttons & IN_USE )*/ ) { // the gay desync
const float delta = std::fabs( math::NormalizedAngle( rec_foot - fake_foot ) );
const float thr = band.pos * ( 1.f + g_cfg.min_desync_pct / 100.f );
if( thr <= delta ) // do not reflick yet
return;
const float mid = rec_foot + math::AngleDiff( fake_foot, rec_foot ) * 0.5f;
*c.yaw = math::NormalizedAngle( mid + 180.f );
m_flick_fired = true;
m_choke_target = 2; // should maybe be 1? who cares, doesnt matter
return;
}
// DoTwist
const float mid = rec_foot + math::AngleDiff( fake_foot, rec_foot ) * 0.5f;
const CPredictedAnimstate s = PredictAnimationState( ctx, me, *c.yaw, CurTime( ) );
const float sim = s.ok ? s.foot_yaw : sim_foot;
const float delta = math::NormalizedAngle( *c.yaw - sim );
const float achieved = math::NormalizedAngle( rec_foot - fake_foot );
const bool d_pos = delta > 0.f;
const bool a_pos = achieved > 0.f;
float out;
if( a_pos ) out = d_pos ? ( fake_foot + band.pos ) : ( band.neg + rec_foot );
else out = d_pos ? ( band.pos + rec_foot ) : ( band.neg + fake_foot );
const float anti = math::NormalizedAngle( mid + 180.f );
const float d = std::fabs( math::NormalizedAngle( *c.yaw - anti ) );
// the actual twist, that follow your fake and not your real
*c.yaw = ( band.pos <= d ) ? math::NormalizedAngle( out ) : anti;
// clamp is needed on transition flick
// 2.f returns 118.f ( at low speed ), clamp it to whatever you want
// your real is almost always band ° away from your fake
// but since your fake drives your real, you're further away from your "base"
// this is how far away you want your head to go from your base yaw
const float lim = band.pos * 1.75f;
const float off = math::AngleDiff( *c.yaw, entry_dir );
if( off > lim ) *c.yaw = math::NormalizedAngle( entry_dir + lim );
if( off < -lim ) *c.yaw = math::NormalizedAngle( entry_dir - lim );
}
inline void Run( ) {
if( !g_cfg.enable || !m_round_start || !HooksReady( ) )
return;
Player* me = g_ctx.local;
Cmd& c = g_ctx.cmd;
if( !me || !c.ok( ) || !Alive( me ) )
return;
CCSGOPlayerAnimState* as = GetAnimState( me );
if( !as )
return;
{
if( g_ctx.grenade ) {
static float throw_time = 0.f;
static bool shiggy = false;
const bool release_m1 = ( g_ctx.buttons & IN_ATTACK ) != ( g_ctx.old_buttons & IN_ATTACK )
&& !( g_ctx.buttons & IN_ATTACK );
const bool release_m2 = ( g_ctx.buttons & IN_ATTACK2 ) != ( g_ctx.old_buttons & IN_ATTACK2 )
&& !( g_ctx.buttons & IN_ATTACK2 );
if( release_m1 || release_m2 ) { // not mercury , will work on most hacks either way
throw_time = CurTime( ) + 0.1f;
if( g_ctx.send_packet )
*g_ctx.send_packet = true;
shiggy = true; // add in air check if u dont wanna pleasure ur break lc
return;
}
if( std::abs( CurTime( ) - throw_time ) <= 0.1f ) { // throwtime is curtime + .1f, frozen on release
if( g_ctx.send_packet )
*g_ctx.send_packet = g_ctx.lag >= 14;
if( shiggy ) // unchoke the 2 first ticks
*g_ctx.send_packet = true;
if( g_ctx.lag == 0 && !shiggy ) { // this is a ghetto fix but will grant you psilent
c.yaw = m_last_sent_yaw;
c.pitch = m_last_sent_pitch;
}
if( CurTime( ) >= throw_time && g_ctx.lag > 0 ) // insta throw
*g_ctx.send_packet = true;
shiggy = false;
return;
}
}
else if( *c.buttons & IN_ATTACK ) // manual shot, should be: prediction::had_attack
return;
const int move_type = MoveType( me );
if( move_type == MOVETYPE_LADDER || move_type == MOVETYPE_NOCLIP )
return;
}
const CCSGOPlayerAnimState_ServerSim* srv = GetServerAnim( me );
if( !srv )
return;
const int entry_seed = c.number & 0xFF;
RandomSeed( entry_seed );
m_wrote_moves = false;
{
if( !( Flags( me ) & FL_ONGROUND )
|| ( ( g_ctx.buttons & IN_JUMP ) && !( g_ctx.flags & FL_ONGROUND ) ) )
m_mode = AIR;
else
m_mode = AbsVelocity( me ).length_2d( ) < 0.1f ? STAND : WALK;
}
Band band;
// wrong by 1 tick, should be resimulated if lag == 0
// also should be re-simulated after extended's move ran
// good enough
{
float t = as->m_flSpeedAsPortionOfWalkTopSpeed;
math::clamp( t, 0.f, 1.f );
float width = math::Lerp( t, 1.0f,
math::Lerp( as->m_flWalkToRunTransition,
CSGO_ANIM_AIM_NARROW_WALK,
CSGO_ANIM_AIM_NARROW_RUN ) );
if( as->m_flAnimDuckAmount > 0.f ) {
float ct = as->m_flSpeedAsPortionOfCrouchTopSpeed;
math::clamp( ct, 0.f, 1.f );
width = math::Lerp( as->m_flAnimDuckAmount * ct, width, CSGO_ANIM_AIM_NARROW_CROUCHMOVING );
}
band.width = width;
band.pos = as->m_flAimYawMax * width;
band.neg = as->m_flAimYawMin * width;
}
const float lby = srv->m_lby;
if( g_ctx.lag != 0 ) // force lby on non animated
*c.yaw = lby;
float yaw = *c.yaw;
CAnimBackup ctx;
{
ctx.valid = false;
if( CCSGOPlayerAnimState* bs = GetAnimState( me ) ) {
std::memcpy( &ctx.state, bs, sizeof( CCSGOPlayerAnimState ) );
GetLayers( me, ctx.layers );
GetPoses ( me, ctx.poses );
ctx.lby = *LowerBodyYaw( me );
ctx.valid = true;
}
ctx.srv_valid = false;
if( CCSGOPlayerAnimState_ServerSim* bsrv = GetServerAnim( me ) ) {
ctx.srv_jumping = bsrv->m_jumping;
ctx.srv_realign_timer = bsrv->m_realign_timer;
ctx.srv_realign_moving = bsrv->m_realign_moving;
ctx.srv_deploy_limit = bsrv->m_deploy_limiting;
ctx.srv_lby = bsrv->m_lby;
ctx.srv_act_mods = bsrv->m_act_mods;
ctx.srv_valid = true;
}
}
// no % 150 ring buffer, too expensive for most people, we also dont need the entire animstate
if( CCSGOPlayerAnimState* pre = m_last_animstate_valid ? &m_last_animstate : as ) {
m_pre_probe_foot = pre->m_flFootYaw;
m_pre_probe_speed = pre->m_flVelocityLengthXY;
m_pre_probe_ground = pre->m_bOnGround;
m_pre_probe_air = pre->m_flDurationInAir;
m_pre_probe_valid = true;
}
else
m_pre_probe_valid = false;
// stand aa stripped
// dogshit anyway
*c.yaw = math::NormalizedAngle( yaw );
{
const CPredictedAnimstate s = PredictAnimationState( ctx, me, *c.yaw, CurTime( ) );
RunDesync( c, me, band, s.ok ? s.foot_yaw : *c.yaw, lby, ctx );
yaw = *c.yaw;
}
AnimationStateRestore( ctx, me );
*c.yaw = math::NormalizedAngle( yaw );
if( ( g_ctx.lag == 0 ) ) {
m_last_sent_yaw = *c.yaw;
m_last_sent_pitch = *c.pitch;
}
{
if( !( Flags( me ) & FL_ONGROUND )
|| ( ( g_ctx.buttons & IN_JUMP ) && !( g_ctx.flags & FL_ONGROUND ) ) )
m_mode = AIR;
else
m_mode = AbsVelocity( me ).length_2d( ) < 0.1f ? STAND : WALK;
}
if( m_mode == WALK && !( AbsVelocity( me ).length( ) > 10.f && !g_ctx.avoid_autostop ) ) {
const float pre_fwd = *c.forward;
const float pre_side = *c.side;
if( g_cfg.limit_speed && g_cfg.extend_desync ) {
const bool was_moving = m_pre_probe_valid ? ( m_pre_probe_speed > 0.1f )
: ( as->m_flVelocityLengthXY > 0.1f );
const bool on_ground = m_pre_probe_valid ? m_pre_probe_ground : as->m_bOnGround;
if( was_moving && on_ground ) {
*c.buttons &= ~IN_SPEED;
float base = CS_PLAYER_SPEED_RUN;
if( !g_ctx.avoid_autostop ) {
const float wmax = MaxWeaponSpeed( me );
base = ( wmax > 0.f ? wmax : 250.f ) * 0.33f;
}
const bool ducking = as->m_flAnimDuckAmount > 0.f;
// on top of being wrong, this is ghetto and could be done better
// https://gitlab.com/KittenPopo/csgo-2018-source/-/blob/main/game/shared/cstrike15/csgo_playeranimstate.cpp#L1449
// https://gitlab.com/KittenPopo/csgo-2018-source/-/blob/main/game/shared/cstrike15/csgo_playeranimstate.cpp#L2271
// layer 6 is 0.f to 52% of velocity, not 60%
// 0.34f is duck, not 0.3f
const float target = ( ducking ? base * CS_PLAYER_SPEED_WALK_MODIFIER : base )
* RandomFloat( 0.3f, 0.6f );
ClampVelocity( c, me, target );
}
}
if( g_cfg.desync_movement && g_cfg.desync && m_desync_engaged
&& g_ctx.avoid_autostop && !g_cfg.extend_desync ) // not mercury, but this breaks layer 11 ( s/o onetap )
{
const float wmax = MaxWeaponSpeed( me );
ClampVelocity( c, me, ( wmax > 0.f ? wmax : 250.f ) * RandomFloat( 0.9f, 1.f ) );
}
if( *c.forward != pre_fwd || *c.side != pre_side ) // tell our hack our deysnc ran movement
m_wrote_moves = true;
}
if( ( g_ctx.lag == 0 ) ) {
m_pitch_out = *c.pitch;
m_yaw_out = *c.yaw;
}
RandomSeed( entry_seed );
}
inline void PostCommand( ) {
if( g_ctx.lag != 0 || !HooksReady( ) )
return;
Player* me = g_ctx.local;
if( !me || !Alive( me ) )
return;
CCSGOPlayerAnimState* s = GetAnimState ( me );
CCSGOPlayerAnimState_ServerSim* srv = GetServerAnim( me );
if( !s || !srv ) {
g_FakeAnims.valid = false;
return;
}
const float fake_yaw = srv->m_lby; // assume thats where they got us resolved
FakeAnim& fa = g_FakeAnims;
if( !fa.valid || fa.state.m_pPlayer != me || g_ctx.spawned ) {
std::memcpy( &fa.state, s, sizeof( CCSGOPlayerAnimState ) );
GetLayers( me, fa.layers );
GetPoses ( me, fa.poses );
fa.lby = *LowerBodyYaw( me );
fa.foot_yaw = s->m_flFootYaw;
fa.srv_jumping = srv->m_jumping;
fa.srv_realign_timer = srv->m_realign_timer;
fa.srv_deploy_limit = srv->m_deploy_limiting;
fa.srv_lby = srv->m_lby;
fa.srv_act_mods = srv->m_act_mods;
fa.valid = true;
}
CCSGOPlayerAnimState bk_state;
C_AnimationLayers bk_layers;
float bk_poses[ 24 ];
std::memcpy( &bk_state, s, sizeof( CCSGOPlayerAnimState ) );
GetLayers( me, bk_layers );
GetPoses ( me, bk_poses );
const float bk_lby = *LowerBodyYaw( me );
const bool bk_jumping = srv->m_jumping;
const float bk_realign = srv->m_realign_timer;
const bool bk_deploy = srv->m_deploy_limiting;
const float bk_svlby = srv->m_lby;
const ActModifiers bk_mods = srv->m_act_mods;
std::memcpy( s, &fa.state, sizeof( CCSGOPlayerAnimState ) );
SetLayers( me, fa.layers );
SetPoses ( me, fa.poses );
s->m_pWeapon = bk_state.m_pWeapon;
s->m_pWeaponLast = bk_state.m_pWeaponLast;
*LowerBodyYaw( me ) = fa.lby;
srv->m_jumping = fa.srv_jumping;
srv->m_realign_timer = fa.srv_realign_timer;
srv->m_deploy_limiting = fa.srv_deploy_limit;
srv->m_lby = fa.srv_lby;
srv->m_act_mods = fa.srv_act_mods;
// should only run SetUpVelocity and SetUpMovement, really
// only body_yaw poseparameters matter here
CCSGOPlayerAnimstate_Update( s, math::NormalizedAngle( fake_yaw ), m_pitch_out, false, true );
std::memcpy( &fa.state, s, sizeof( CCSGOPlayerAnimState ) );
GetPoses ( me, fa.poses );
fa.lby = *LowerBodyYaw( me );
fa.foot_yaw = s->m_flFootYaw;
fa.srv_jumping = srv->m_jumping;
fa.srv_realign_timer = srv->m_realign_timer;
fa.srv_deploy_limit = srv->m_deploy_limiting;
fa.srv_lby = srv->m_lby;
fa.srv_act_mods = srv->m_act_mods;
std::memcpy( s, &bk_state, sizeof( CCSGOPlayerAnimState ) );
SetLayers( me, bk_layers );
GetLayers( me, fa.layers ); // our client layers ARE networked, you do not need this
SetPoses ( me, bk_poses );
*LowerBodyYaw( me ) = bk_lby;
srv->m_jumping = bk_jumping;
srv->m_realign_timer = bk_realign;
srv->m_deploy_limiting = bk_deploy;
srv->m_lby = bk_svlby;
srv->m_act_mods = bk_mods;
}was planning to make this code public but i had some stuff going on
s/o simon freese(pxnch), andre(vega), puzzlepirate(rome the pedo, s/o exitscambot), errera (una, free spoonfeed for pxnch), claude and deepseek
ps: nice update pxnch, broke the entire hack btw LOL
note:
this code was sloppified purposefully to not be copy paste ready
this was btw spoonfed from rome/errera to pxnch, this is straight up Get Banned from moneybot hello @rome, hows grooming kids going along?
ive also removed the fakelag and the rest of the antiaim along with adding one feature or two to the desync (happy pasting)
for any other inquiries dm on forums
and for anyone still paying for pxnch's dogshit, reconsider your life choices
Last edited by a moderator:
