void CCSGameMovement::PlayerMove()
{
        if ( !m_pCSPlayer->CanMove() )
        {
                mv->m_flForwardMove = 0;
                mv->m_flSideMove = 0;
                mv->m_flUpMove = 0;
                mv->m_nButtons &= ~(IN_JUMP | IN_FORWARD | IN_BACK | IN_MOVELEFT | IN_MOVERIGHT);
        }

        BaseClass::PlayerMove();

        if ( FBitSet( m_pCSPlayer->GetFlags(), FL_ONGROUND ) )
        {
                if ( m_pCSPlayer->m_flVelocityModifier < 1.0 )
                {
                        m_pCSPlayer->m_flVelocityModifier += gpGlobals->frametime / 3.0f;
                }

                if ( m_pCSPlayer->m_flVelocityModifier > 1.0 )
                         m_pCSPlayer->m_flVelocityModifier = 1.0;
        }

        if ( m_pCSPlayer->IsAlive() )
        {
                // Check if our eye height is too close to the ceiling and lower it.
                // This is needed because we have taller models with the old collision bounds.

                const float eyeClearance = 12.0f; // eye pos must be this far below the ceiling

                Vector offset = player->GetViewOffset();

                Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
                vHullMin.z = 0.0f;
                Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );

                Vector start = player->GetAbsOrigin();
                start.z += vHullMax.z;
                Vector end = start;
                end.z += eyeClearance - vHullMax.z;
                end.z += player->m_Local.m_bDucked ? VEC_DUCK_VIEW.z : VEC_VIEW.z;

                vHullMax.z = 0.0f;

                Vector fudge( 1, 1, 0 );
                vHullMin += fudge;
                vHullMax -= fudge;

                trace_t trace;
                Ray_t ray;
                ray.Init( start, end, vHullMin, vHullMax );
                UTIL_TraceRay( ray, PlayerSolidMask(), mv->m_nPlayerHandle.Get(), COLLISION_GROUP_PLAYER_MOVEMENT, &trace );

                if ( trace.fraction < 1.0f )
                {
                        float est = start.z + trace.fraction * (end.z - start.z) - player->GetAbsOrigin().z - eyeClearance;
                        if ( ( player->GetFlags() & FL_DUCKING ) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked )
                        {
                                offset.z = est;
                        }
                        else
                        {
                                offset.z = min( est, offset.z );
                        }
                        player->SetViewOffset( offset );
                }
                else
                {
                        if ( ( player->GetFlags() & FL_DUCKING ) == 0 && !player->m_Local.m_bDucking && !player->m_Local.m_bDucked )
                        {
                                player->SetViewOffset( VEC_VIEW );
                        }
                        else if ( m_pCSPlayer->m_duckUntilOnGround )
                        {
                                // Duck Hull, but we're in the air.  Calculate where the view would be.
                                Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
                                Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;

                                // We've got the duck hull, pulled up to the top of where the player should be
                                Vector lowerClearance = hullSizeNormal - hullSizeCrouch;
                                Vector duckEyeHeight = GetPlayerViewOffset( false ) - lowerClearance;
                                player->SetViewOffset( duckEyeHeight );
                        }
                        else if( player->m_Local.m_bDucked && !player->m_Local.m_bDucking )
                        {
                                player->SetViewOffset( VEC_DUCK_VIEW );
                        }
                }
        }
}