Vector     vecIronsightPosOffset;
  QAngle     angIronsightAngOffset;
  float     flIronsightFOVOffset;

    KeyValues *pSights = pKeyValuesData->FindKey( "IronSight" );
  if (pSights)
  {
   vecIronsightPosOffset.x  = pSights->GetFloat( "forward", 0.0f );
   vecIronsightPosOffset.y  = pSights->GetFloat( "right", 0.0f );
   vecIronsightPosOffset.z  = pSights->GetFloat( "up", 0.0f );
   
   angIronsightAngOffset[PITCH]    = pSights->GetFloat( "pitch", 0.0f );
   angIronsightAngOffset[YAW]  = pSights->GetFloat( "yaw", 0.0f );
   angIronsightAngOffset[ROLL]  = pSights->GetFloat( "roll", 0.0f );
   
   flIronsightFOVOffset  = pSights->GetFloat( "fov", 0.0f );
  }
  else
  {
   //note: you can set a bool here if you'd like to disable ironsights for weapons with no IronSight-key
   vecIronsightPosOffset = vec3_origin;
   angIronsightAngOffset.Init();
   flIronsightFOVOffset = 0.0f;
  }

    IronSight
  {
   "forward"    "-10"
   "right"  "-6.91"
   "up"  "0.185"
   "roll"  "-20"
   "fov"  "-20"
  }

    Vector     GetIronsightPositionOffset( void ) const;
  QAngle     GetIronsightAngleOffset( void ) const;
  float     GetIronsightFOVOffset( void ) const;

  virtual bool    HasIronsights( void ) { return true; } //default yes; override and return false for weapons with no ironsights (like weapon_crowbar)
  bool     IsIronsighted( void );
  void     ToggleIronsights( void ) { m_bIsIronsighted ? DisableIronsights() : EnableIronsights(); }
  void     EnableIronsights( void );
  void     DisableIronsights( void );

//forward declarations of callbacks used by viewmodel_adjust_enable and viewmodel_adjust_fov
void vm_adjust_enable_callback( IConVar *pConVar, char const *pOldString, float flOldValue );
void vm_adjust_fov_callback( IConVar *pConVar, const char *pOldString, float flOldValue );
   
ConVar viewmodel_adjust_forward( "viewmodel_adjust_forward", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_right( "viewmodel_adjust_right", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_up( "viewmodel_adjust_up", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_pitch( "viewmodel_adjust_pitch", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_yaw( "viewmodel_adjust_yaw", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_roll( "viewmodel_adjust_roll", "0", FCVAR_REPLICATED );
ConVar viewmodel_adjust_fov( "viewmodel_adjust_fov", "0", FCVAR_REPLICATED, "Note: this feature is not available during any kind of zoom", vm_adjust_fov_callback );
ConVar viewmodel_adjust_enabled( "viewmodel_adjust_enabled", "0", FCVAR_REPLICATED|FCVAR_CHEAT, "enabled viewmodel adjusting", vm_adjust_enable_callback );

Vector CBaseCombatWeapon::GetIronsightPositionOffset( void ) const
{
  if( viewmodel_adjust_enabled.GetBool() )
   return Vector( viewmodel_adjust_forward.GetFloat(), viewmodel_adjust_right.GetFloat(), viewmodel_adjust_up.GetFloat() );
  return GetWpnData().vecIronsightPosOffset;
}
   
QAngle CBaseCombatWeapon::GetIronsightAngleOffset( void ) const
{
  if( viewmodel_adjust_enabled.GetBool() )
   return QAngle( viewmodel_adjust_pitch.GetFloat(), viewmodel_adjust_yaw.GetFloat(), viewmodel_adjust_roll.GetFloat() );
  return GetWpnData().angIronsightAngOffset;
}
   
float CBaseCombatWeapon::GetIronsightFOVOffset( void ) const
{
  if( viewmodel_adjust_enabled.GetBool() )
   return viewmodel_adjust_fov.GetFloat();
  return GetWpnData().flIronsightFOVOffset;
}

bool CBaseCombatWeapon::IsIronsighted( void )
{
  return ( m_bIsIronsighted || viewmodel_adjust_enabled.GetBool() );
}
   
void CBaseCombatWeapon::EnableIronsights( void )
{
  if( !HasIronsights() || m_bIsIronsighted )
   return;
   
  CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
   
  if( !pOwner )
   return;
   
  if( pOwner->SetFOV( this, pOwner->GetDefaultFOV()+GetIronsightFOVOffset(), 1.0f ) ) //modify the last value to adjust how fast the fov is applied
  {
   m_bIsIronsighted = true;
   m_flIronsightedTime = gpGlobals->curtime;
  }
}
   
void CBaseCombatWeapon::DisableIronsights( void )
{
  if( !HasIronsights() || !m_bIsIronsighted )
   return;
   
  CBasePlayer *pOwner = ToBasePlayer( GetOwner() );
   
  if( !pOwner )
   return;
   
  if( pOwner->SetFOV( this, 0, 0.4f ) ) //modify the last value to adjust how fast the fov is applied
  {
   m_bIsIronsighted = false;
   m_flIronsightedTime = gpGlobals->curtime;
  }
}
   
void vm_adjust_enable_callback( IConVar *pConVar, char const *pOldString, float flOldValue )
{
  ConVarRef sv_cheats( "sv_cheats" );
  if( !sv_cheats.IsValid() || sv_cheats.GetBool() )
   return;
   
  ConVarRef var( pConVar );
   
  if( var.GetBool() )
   var.SetValue( "0" );
}
   
void vm_adjust_fov_callback( IConVar *pConVar, char const *pOldString, float flOldValue )
{
  if( !viewmodel_adjust_enabled.GetBool() )
   return;
   
  ConVarRef var( pConVar );
   
  CBasePlayer *pPlayer =  
#ifdef GAME_DLL
   UTIL_GetLocalPlayer();
#else
   C_BasePlayer::GetLocalPlayer();
#endif
  if( !pPlayer )
   return;
   
  if( !pPlayer->SetFOV( pPlayer, pPlayer->GetDefaultFOV()+var.GetFloat(), 0.1f ) )
  {
   Warning( "Could not set FOV\n" );
   var.SetValue( "0" );
  }
}

    CNetworkVar( bool, m_bIsIronsighted );
  CNetworkVar( float, m_flIronsightedTime );

    m_bIsIronsighted = false;
  m_flIronsightedTime = 0.0f;

BEGIN_NETWORK_TABLE(CBaseCombatWeapon, DT_BaseCombatWeapon)
#if !defined( CLIENT_DLL )

    SendPropBool( SENDINFO( m_bIsIronsighted ) ),
  SendPropFloat( SENDINFO( m_flIronsightedTime ) ),

    RecvPropInt( RECVINFO( m_bIsIronsighted ), 0, RecvProxy_ToggleSights ), //note: RecvPropBool is actually RecvPropInt (see its implementation), but we need a proxy
  RecvPropFloat( RECVINFO( m_flIronsightedTime ) ),

BEGIN_NETWORK_TABLE(CBaseCombatWeapon, DT_BaseCombatWeapon)

#if defined( CLIENT_DLL )
void RecvProxy_ToggleSights( const CRecvProxyData *pData, void *pStruct, void *pOut ) //;
{
  CBaseCombatWeapon *pWeapon = (CBaseCombatWeapon*)pStruct;
  pData->m_Value.m_Int ? pWeapon->EnableIronsights() : pWeapon->DisableIronsights();
}
#endif

BEGIN_PREDICTION_DATA( CBaseCombatWeapon )

    DEFINE_PRED_FIELD( m_bIsIronsighted, FIELD_BOOLEAN, FTYPEDESC_INSENDTABLE ),
  DEFINE_PRED_FIELD( m_flIronsightedTime, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),

DEFINE_PRED_FIELD( m_flTimeWeaponIdle, FIELD_FLOAT, FTYPEDESC_INSENDTABLE ),

    DEFINE_FIELD( m_bIsIronsighted, FIELD_BOOLEAN ),
  DEFINE_FIELD( m_flIronsightedTime, FIELD_FLOAT ),

static ConCommand soundscape_dumpclient("soundscape_dumpclient", CC_DumpClientSoundscapeData, "Dumps the client's soundscape data.\n", FCVAR_CHEAT);

void CC_ToggleIronSights( void )
{
  C_BasePlayer *pPlayer = C_BasePlayer::GetLocalPlayer();  
  if ( pPlayer == NULL )
   return;
   
  CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
  if( pWeapon == NULL )
   return;
   
  pWeapon->ToggleIronsights();
   
  engine->ServerCmd( "toggle_ironsight" ); //forward to server //ServerCommand
}
   
static ConCommand toggle_ironsight("toggle_ironsight", CC_ToggleIronSights);

...
   CBasePlayer *pl = UTIL_PlayerByIndex( nRecip );
   if ( pl )
   {
    pl->DumpPerfToRecipient( this, nRecords );
   }
   return true;
  }

else if( stricmp( cmd, "toggle_ironsight" ) == 0 )
{
  CBaseCombatWeapon *pWeapon = GetActiveWeapon();
  if( pWeapon != NULL )
   pWeapon->ToggleIronsights();
   
  return true;
}

DisableIronsights();

bool CBaseCombatWeapon::Holster( CBaseCombatWeapon *pSwitchingTo )

void CBaseCombatWeapon::Drop( const Vector &vecVelocity )

bool CBaseCombatWeapon::Reload( void )

DisableIronsights();

void CBaseViewModel::CalcIronsights( Vector &pos, QAngle &ang )
{
  CBaseCombatWeapon *pWeapon = GetOwningWeapon();
   
  if ( !pWeapon )
   return;
   
  //get delta time for interpolation
  float delta( ( gpGlobals->curtime - pWeapon->m_flIronsightedTime ) / 0.4f ); //modify this value to adjust how fast the interpolation is
  float exp = ( pWeapon->IsIronsighted() ) ?  
   ( delta > 1.0f ) ? 1.0f : delta : //normal blending
   ( delta > 1.0f ) ? 0.0f : 1.0f - delta; //reverse interpolation
   
  if( exp == 0.0f ) //fully not ironsighted; save performance
   return;
   
  Vector newPos = pos;
  QAngle newAng = ang;
   
  Vector vForward, vRight, vUp, vOffset;
  AngleVectors( newAng, &vForward, &vRight, &vUp );
  vOffset = pWeapon->GetIronsightPositionOffset();
   
  newPos += vForward * vOffset.x;
  newPos += vRight * vOffset.y;
  newPos += vUp * vOffset.z;
  newAng += pWeapon->GetIronsightAngleOffset();
  //fov is handled by CBaseCombatWeapon
   
  pos += ( newPos - pos ) * exp;
  ang += ( newAng - ang ) * exp;
}

void CBaseViewModel::CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles )
{
  // UNDONE: Calc this on the server?  Disabled for now as it seems unnecessary to have this info on the server
#if defined( CLIENT_DLL )
  QAngle vmangoriginal = eyeAngles;
  QAngle vmangles = eyeAngles;
  Vector vmorigin = eyePosition;

  CBaseCombatWeapon *pWeapon = m_hWeapon.Get();
  //Allow weapon lagging
  if ( pWeapon != NULL )
  {
#if defined( CLIENT_DLL )
   if ( !prediction->InPrediction() )
#endif
   {
    // add weapon-specific bob  
    pWeapon->AddViewmodelBob( this, vmorigin, vmangles );
   }
  }
  // Add model-specific bob even if no weapon associated (for head bob for off hand models)
  AddViewModelBob( owner, vmorigin, vmangles );
  // Add lag
  CalcViewModelLag( vmorigin, vmangles, vmangoriginal );

#if defined( CLIENT_DLL )
  if ( !prediction->InPrediction() )
  {
   // Let the viewmodel shake at about 10% of the amplitude of the player's view
   vieweffects->ApplyShake( vmorigin, vmangles, 0.1 );  
  }
#endif

  SetLocalOrigin( vmorigin );
  SetLocalAngles( vmangles );

#endif
}

void CBaseViewModel::CalcViewModelView( CBasePlayer *owner, const Vector& eyePosition, const QAngle& eyeAngles )
{
  // UNDONE: Calc this on the server?  Disabled for now as it seems unnecessary to have this info on the server
#if defined( CLIENT_DLL )
  QAngle vmangoriginal = eyeAngles;
  QAngle vmangles = eyeAngles;
  Vector vmorigin = eyePosition;
   
  CBaseCombatWeapon *pWeapon = m_hWeapon.Get();
  //Allow weapon lagging
  //only if not in ironsight-mode
  if( pWeapon == NULL || !pWeapon->IsIronsighted() )
  {
   if ( pWeapon != NULL )
   {
  #if defined( CLIENT_DLL )
    if ( !prediction->InPrediction() )
  #endif
    {
     // add weapon-specific bob  
     pWeapon->AddViewmodelBob( this, vmorigin, vmangles );
    }
   }
   
   // Add model-specific bob even if no weapon associated (for head bob for off hand models)
   AddViewModelBob( owner, vmorigin, vmangles );
   
   // Add lag
   CalcViewModelLag( vmorigin, vmangles, vmangoriginal );
   
#if defined( CLIENT_DLL )
   if ( !prediction->InPrediction() )
   {
    // Let the viewmodel shake at about 10% of the amplitude of the player's view
    vieweffects->ApplyShake( vmorigin, vmangles, 0.1 );  
   }
#endif
  }
   
  CalcIronsights( vmorigin, vmangles );
   
  SetLocalOrigin( vmorigin );
  SetLocalAngles( vmangles );
   
#endif
}

    virtual void   CalcViewModelLag( Vector& origin, QAngle& angles, QAngle& original_angles );

  void  CalcIronsights( Vector &pos, QAngle &ang );

virtual const Vector& GetBulletSpread( void )
  {
    static const Vector cone = VECTOR_CONE_5DEGREES;
    return cone;
  }

virtual const Vector& GetBulletSpread( void )
  {
   if ( m_bIsIronsighted )
   {
    static const Vector cone = VECTOR_CONE_1DEGREES; //разброс в прицеливании
    return cone;
   }
   else
   {
    static const Vector cone = VECTOR_CONE_5DEGREES; //разброс вне прицеливания
    return cone;
   }
  }

"toggle_ironsight"  "MOD_Toggle_Ironsight"

"MOD_Toggle_Ironsight" "Iron Sight"

"MOD_Toggle_Ironsight" "Прицеливание" //или что нибудь на усмотрение

pData->m_Value.m_Int ? pWeapon->EnableIronsights() : pWeapon->DisableIronsights();

  const char *IronSightSound = pWeapon->IsIronsighted() ?  "WWIPlayer.IronSightIn" : "WWIPlayer.IronSightOut";
   pPlayer->EmitSound( IronSightSound );