C++ Function mercury desync code(or moneybots Get Banned)

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;
}