//+-----------------------------------------------------------------------+
//|                                                       Interceptor.mq4 |
//|                                                                Sergey |
//|                                                     mserega@yandex.ru |
//+-----------------------------------------------------------------------+
#property copyright "Sergey"
#property link      "mserega@yandex.ru"
//+-----------------------------------------------------------------------+

//советник для графика М5 GBP/USD

//период тестирования 01.01.2000 - 10.07.2012 (12 лет)

//сделок  321, прибыль 2157, просадка 145, прибыльность 4.1 (закрытие по тейк профиту)

extern double   LotPoz =   0.01;  //лот при обычном открытии позиции (если нет совпадения сигналов)

extern double  KoefYzk =   0.35;  //коэффициэнт узкости флета на М5 (количество пунктов на 1 бар)


extern int     StopLos =   50;  //начальный стоп лосс  (если меньше 10, то стоп лосс не ставится)

extern int     TeikPro =    0;  //тейк профит (если меньше 10, то тейк профит не ставится)

extern int      ProfBy =    0;  //минимальная прибыль в пунктах после перевода в безубыток

extern int      StopBy =   45;  //стоп-лосс после перевода в безубыток (переводим в б/у, если параметр больше 9)


extern int        YzM5 =   25;  //максимально допустимое расстояние между МА для веера на графике  М5 (только в сигнал 1)

extern int       YzM15 =   20;  //максимально допустимое расстояние между МА для веера на графике М15 (только в сигнал 4)

extern int        YzH1 =   60;  //максимально допустимое расстояние между МА для веера на графике М15 (только в сигнал 6)


extern int     StohPer =   24;  //период стохастика (для М5)

extern int     StochUp =   85;  //верхний уровень стохастика (для М5)

extern int     StochDn =   15;  //нижний уровень стохастика (для М5)


extern int    SthBigPr =   24;  //период стохастика (для М15)

extern int    SthBigUp =   85;  //верхний уровень стохастика (для М15)

extern int    SthBigDn =   15;  //нижний уровень стохастика (для М15)


extern int     RazmTel =   15;  //минимальный размер тела свечи (только в сигнал 1)

extern int     MalFlet =   10;  //маленький флет (минимальная длина флета в барах)

extern int     VisFlet =   15;  //высокий флет (максимальная высота флета в пунктах)


extern int     RastDiv =   75;  //минимальное расстояние в барах между пиками индикатора для дивергенции на М5


extern int      BigTen =   80;  //минимальный  процент длинной  тени молота

extern int      LitTen =   10;  //максимальный процент короткой тени молота

extern int      MolRaz =   11;  //минимальный  размер  молота в пунктах (на графике М5)

extern int      MolBar =    8;  //как давно был молот (максимальный номер его бара)

extern int      MolPer =   15;  //на скольких барах молот является максимумом (только в сигнал 6)


extern int       YzIst =    3;  //узкий источник (максимальная ширина веера на М5 в самой узкой точке)

extern int       DalYz =    5;  //сколько баров назад веер сходился в "узкий источник" (практически в точку)

extern int       KolBr =   10;  //диапазон максимума или минимума, который пробивается ("узкий источник")

extern int       Magic = 1214;  //пометка своих ордеров таким номером


extern int    StepTral =   50;  //минимальный сдвиг тралинг-стопа

extern int    DistTral =  300;  //расстояние от тралинг-стопа до цены (если меньше 10, то трал не работает)

//лоты открытых позиций
double lot_buy, lot_sel;

//вееры скользящих средних, коэффициэнт лота (если совпали несколько сигналов сразу, то открываем двойной лот)
int veer_m5, veer_15, veer_h1, lt_koef;

//пересечение стохастика и сигнальной линии на графике М5, на графике М15, бар для цикла
int stoch_crosM5, stoh_per15;

//пробой скользящих средних M5 и M15, пробой флета на М5, горн (улучшенная версия веера МА)
int prob_m5, prob_15, prb_flt, hrn_bull, hrn_bear, prb_yz;

//дивергенция на стохастике М5, бар где есть молот, значение молота
int div_buy, div_sel, mltbr, molot;

//сигналы управления ордерами
int zakr_buy, zakr_sel, otkr_buy, otkr_sel;

//время открытия бара 1 на текущем и предыдущем тике
datetime vrem_new, vrem_old;

//комментарий к ордеру (причина открытия)
string prichina;

//=========================================================================
int init()
{  
   Comment("\nЗАПУСК СОВЕТНИКА");
   
   if(Period() != PERIOD_M5)
   { 
      MessageBox("Нужно выбрать период M5"); 
   }
   
   if(Symbol() != "GBPUSD")
   {
      MessageBox("Нужно выбрать валюту GBP/USD");
   }
   
   vrem_old=Time[2];
   
   return(0);
}
//=========================================================================
int deinit()
{  
   return(0);
}
//=========================================================================
//+-----------------------------------------------------------------------+
int start()
{
   //расстояния между крайними скользящими средними
   int dist_m5, dist_15, dist_h1; 
   
   
   //время открытия бара 1 на текущем тике
   vrem_new=Time[1];
   
   //если это новый бар
   if(vrem_new!=vrem_old)
   {      
      //обнуляем сигналы управления ордерами, выполняем анализ и расчеты
      zakr_buy=0; zakr_sel=0; otkr_buy=0; otkr_sel=0; prichina="СИГНАЛОВ НЕ БЫЛО"; lt_koef=0;
   
      analyz_m5(veer_m5, dist_m5, prob_m5);
      
      analyz_15(veer_15, dist_15, prob_15);
      
      analyz_H1(veer_h1, dist_h1);
   
      stoch_crosM5 = analyz_stoch();
      
      prb_flt = proboy_fleta();
      
      
      hrn_bull = ophorn_bull(1);
      
      hrn_bear = ophorn_bear(1);
      
      prb_yz = prob_yzk(1);
      
      
      div_buy = diver_bull(4);
      
      div_sel = diver_bear(4);
      
      //пересечение стохастика и сигнальной линии в крайней зоне на М15
      stoh_per15 = cros_big_stoh(1);
      
      //находим ближайший бар, где есть молот и направление молота
      //если у нас есть два молота, засчитывается только ближайший
      molot = 0; mltbr=0;
      
      for(mltbr=1; mltbr<20; mltbr++)
      {
         molot = opr_molot(mltbr);
         
         if(molot != 0) {break;}   
      }
      
         
   
      //сигнал 1 : узкий веер на М5, большая свеча, пересечение стохастика в крайней зоне
      //----------------------------------------------------------------------
      if(dist_m5<YzM5) 
      {
         if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0)&&(stoch_crosM5>0))
         {
            if((Open[1]+RazmTel*Point)<Close[1])
            {
               otkr_buy = 1;
               
               lt_koef++;
      
               prichina = "veer and stoch";
            }
         }
         //-------------------------------------------------------------------
         if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0)&&(stoch_crosM5<0))
         {
            if((Open[1]-RazmTel*Point)>Close[1])
            {
               otkr_sel = 1;
               
               lt_koef++;
      
               prichina = "veer and stoch";
            }
         }
      }   
      //----------------------------------------------------------------------
      
      
      //сигнал 2 : пробой веера средних на М5, у свечи нет задней тени
      //----------------------------------------------------------------------
      if(prob_m5>0) 
      {
         if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0)&&(Open[1]==Low[1]))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "proboy m5";
         }
      }
      //----------------------------------------------------------------------
      if(prob_m5<0)
      {  
         if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0)&&(Open[1]==High[1]))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "proboy m5";
         }
      }   
      //----------------------------------------------------------------------
      
      
      //сигнал 3 : пробой узкого флета по тренду на графике М5
      //----------------------------------------------------------------------
      if(prb_flt>0) 
      {
         if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "proboy fleta";
         }
      }
      //----------------------------------------------------------------------
      if(prb_flt<0)
      {  
         if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "proboy fleta";
         }
      }   
      //----------------------------------------------------------------------
      
      
      //сигнал 4 : пробой скользящих средних на М5 и на М15, узость МА на М15
      //----------------------------------------------------------------------
      if(prob_15>0) 
      {
         if((prob_m5>0)&&(veer_15>0)&&(veer_h1>0)&&(dist_15<YzM15))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "proboy 3x";
         }
      }
      //----------------------------------------------------------------------
      if(prob_15<0)
      {  
         if((prob_m5<0)&&(veer_15<0)&&(veer_h1<0)&&(dist_15<YzM15))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "proboy 3x";
         }
      }   
      //----------------------------------------------------------------------
      
      
      
      //сигнал 5 : дивергенция стохастика на М5
      //----------------------------------------------------------------------
      if(div_buy>0) 
      {
         if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "diver stoch";
         }
      }
      //----------------------------------------------------------------------
      if(div_sel>0)
      {  
         if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "diver stoch";
         }
      }   
      //----------------------------------------------------------------------
      
      
      //сигнал 6 : молот на М5 по тренду
      //----------------------------------------------------------------------
      if( (mltbr <= MolBar) && (dist_h1<YzH1) ) 
      {
         if( (molot>0) && (mltbr == iLowest(NULL,0,MODE_LOW,MolPer,1)) && (Open[1]<Close[1]) )
         {
            if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0))
            {
               otkr_buy = 1;
            
               lt_koef++;
      
               prichina = "molot";
            }            
         }
      //----------------------------------------------------------------------
         if( (molot<0) && (mltbr == iHighest(NULL,0,MODE_HIGH,MolPer,1)) && (Open[1]>Close[1]) )
         {
            if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0))
            {
               otkr_sel = 1;
            
               lt_koef++;
      
               prichina = "molot";
            }         
         }
      }   
      //----------------------------------------------------------------------
      
      
      //сигнал 7 : пересечение стохастика на М15 в крайней зоне по тренду
      //----------------------------------------------------------------------
      if(stoh_per15>0) 
      {
         if((veer_m5>0)&&(veer_15>0)&&(veer_h1>0))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "stoh15";
         }            
      }
      //----------------------------------------------------------------------
      if(stoh_per15<0)
      {
         if((veer_m5<0)&&(veer_15<0)&&(veer_h1<0))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "stoh15";
         }         
      } 
      //----------------------------------------------------------------------
      
      
      //сигнал 8 : горн (очень узкий веер на М5), цена пробивает диапазон
      //----------------------------------------------------------------------
      if(prb_yz>0) 
      {
         if((hrn_bull>0)&&(veer_15>0)&&(veer_h1>0)&&(hrn_bull<DalYz))
         {
            otkr_buy = 1;
            
            lt_koef++;
      
            prichina = "horn_bull";
         }            
      }
      //----------------------------------------------------------------------
      if(prb_yz<0) 
      {
         if((hrn_bear>0)&&(veer_15<0)&&(veer_h1<0)&&(hrn_bear<DalYz))
         {
            otkr_sel = 1;
            
            lt_koef++;
      
            prichina = "horn_bear";
         }            
      } 
      //----------------------------------------------------------------------
                                            
      
      
      //если открываем позицию, то закрываем противоположную
      
      if(otkr_buy==1)  {zakr_sel = 2;}  
      
      if(otkr_sel==1)  {zakr_buy = 2;}
      
      
      
      //если закрываем позицию, то отменяем сигнал к открытию
      
      if(zakr_buy==2)  {otkr_buy=0;}
      
      if(zakr_sel==2)  {otkr_sel=0;}
      
       
      //вывод на экран результатов расчетов
      Comment("\nVEER_M5 = ",veer_m5,"   DIST_M5 = ",dist_m5,
      "\n\nVEER_15 = ",veer_15,"   DIST_15 = ",dist_15,
      "\n\nVEER_h1 = ",veer_h1,"   dist_h1 = ",dist_h1,
      "\n\nPRB_FLT = ",prb_flt,
      "\n\nSTOCH_CROSM5 = ",stoch_crosM5);
                 
   
      //расчеты выполнены, теперь это не новый бар
      vrem_old = vrem_new;
   }
   
   //закрываем и модифицируем имеющиеся ордера
   perebor_orderov(zakr_buy, zakr_sel);  
   
   //подсчитываем лоты открытых позиций
   podschet_orderov(lot_buy ,lot_sel);
   
   //установка бая
   if((otkr_buy==1)&&(lot_buy<0.01))
   {
      ystanovit_buy(prichina, lt_koef);
   }
   
   //установка села
   if((otkr_sel==1)&&(lot_sel<0.01))
   {
      ystanovit_sel(prichina, lt_koef);
   }
   
   return(0);
}
//+-----------------------------------------------------------------------+
//=========================================================================
//анализ скользящих средних на графике М5 (на текущем графике)
void analyz_m5(int &veer, int &dist, int &prob)
{
   double ma[5];
   
   int v, n;
   
   double vma, nma, rast;
   
   veer = 0;  prob=0;
   
   //считываем скользящие средние на баре 1
   ma[0] = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,1);
   ma[1] = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,1);
   ma[2] = iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE,1);
   ma[3] = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,1);
   ma[4] = iMA(NULL,0,233,0,MODE_EMA,PRICE_CLOSE,1);
   
   //верхняя скользящая средняя
   v = ArrayMaximum(ma);
   vma = ma[v];
      
   //нижняя скользящая средняя
   n = ArrayMinimum(ma);
   nma = ma[n];
   
   //расстояние между верхней и нижней МА в пунктах
   rast = (vma-nma)/Point;
   dist = NormalizeDouble(rast, 0);
   
   //округлим три легкие МА до 4 знаков после запятой
   ma[0] = NormalizeDouble(ma[0], Digits);
   ma[1] = NormalizeDouble(ma[1], Digits);
   ma[2] = NormalizeDouble(ma[2], Digits);
                  
   //веер вверх
   if( (ma[4]<ma[3]) && (ma[3]<ma[2]) && (ma[2]<=ma[1]) && (ma[1]<=ma[0]) ) {veer = 1;}
   
   //веер вниз
   if( (ma[4]>ma[3]) && (ma[3]>ma[2]) && (ma[2]>=ma[1]) && (ma[1]>=ma[0]) ) {veer =-1;}
   
   
   //пробой вверх
   if((Open[1]<nma)&&(Close[1]>vma)) {prob = 1;}
   
   //пробой вниз
   if((Open[1]>vma)&&(Close[1]<nma)) {prob =-1;}   
   
   return;  
}
//=========================================================================
//анализ скользящих средних на графике М15
void analyz_15(int &veer, int &dist, int &prob)
{
   double ma[5];
   
   int v, n;
   
   double vma, nma, rast, op_15, cl_15;
   
   veer = 0; prob=0;
   
   //считываем скользящие средние на баре 1
   ma[0] = iMA(NULL,PERIOD_M15,34,0,MODE_EMA,PRICE_CLOSE,1);
   ma[1] = iMA(NULL,PERIOD_M15,55,0,MODE_EMA,PRICE_CLOSE,1);
   ma[2] = iMA(NULL,PERIOD_M15,89,0,MODE_EMA,PRICE_CLOSE,1);
   ma[3] = iMA(NULL,PERIOD_M15,144,0,MODE_EMA,PRICE_CLOSE,1);
   ma[4] = iMA(NULL,PERIOD_M15,233,0,MODE_EMA,PRICE_CLOSE,1);
   
   //верхняя скользящая средняя
   v = ArrayMaximum(ma);
   vma = ma[v];
      
   //нижняя скользящая средняя
   n = ArrayMinimum(ma);
   nma = ma[n];
   
   //расстояние между верхней и нижней МА в пунктах
   rast = (vma-nma)/Point;
   dist = NormalizeDouble(rast, 0);
   
   //округлим две легкие МА до 4 знаков после запятой
   ma[0] = NormalizeDouble(ma[0], Digits);
   ma[1] = NormalizeDouble(ma[1], Digits);
                  
   //веер вверх
   if( (ma[4]<ma[3]) && (ma[3]<ma[2]) && (ma[2]<ma[1]) && (ma[1]<=ma[0]) ) {veer = 1;}
   
   //веер вниз
   if( (ma[4]>ma[3]) && (ma[3]>ma[2]) && (ma[2]>ma[1]) && (ma[1]>=ma[0]) ) {veer =-1;}
   
   
   //определение пробоя трех быстрых скользящих средних на графике М15
   op_15 = iOpen(NULL,PERIOD_M15,1);
   
   cl_15 = iClose(NULL,PERIOD_M15,1);
   
   if((op_15>0)&&(cl_15>0))
   {
      if((op_15<ma[0])&&(op_15<ma[1])&&(op_15<ma[2]))
      {
         if((cl_15>ma[0])&&(cl_15>ma[1])&&(cl_15>ma[2])) {prob = 1;}
      }
   
      if((op_15>ma[0])&&(op_15>ma[1])&&(op_15>ma[2]))
      {
         if((cl_15<ma[0])&&(cl_15<ma[1])&&(cl_15<ma[2])) {prob =-1;}
      }
   }   
   
   return;  
}
//=========================================================================
//анализ скользящих средних на графике H1
void analyz_H1(int &veer, int &dist)
{
   double ma[5];
   
   int v, n;
   
   double vma, nma, rast;
   
   veer = 0;
   
   //считываем скользящие средние на баре 1
   ma[0] = iMA(NULL,PERIOD_H1,34,0,MODE_EMA,PRICE_CLOSE,1);
   ma[1] = iMA(NULL,PERIOD_H1,55,0,MODE_EMA,PRICE_CLOSE,1);
   ma[2] = iMA(NULL,PERIOD_H1,89,0,MODE_EMA,PRICE_CLOSE,1);
   ma[3] = iMA(NULL,PERIOD_H1,144,0,MODE_EMA,PRICE_CLOSE,1);
   ma[4] = iMA(NULL,PERIOD_H1,233,0,MODE_EMA,PRICE_CLOSE,1);
   
   //верхняя скользящая средняя
   v = ArrayMaximum(ma);
   vma = ma[v];
      
   //нижняя скользящая средняя
   n = ArrayMinimum(ma);
   nma = ma[n];
   
   //расстояние между верхней и нижней МА в пунктах
   rast = (vma-nma)/Point;
   dist = NormalizeDouble(rast, 0);
                  
   //веер вверх
   if( (ma[4]<ma[3]) && (ma[3]<ma[2]) && (ma[2]<ma[1]) && (ma[1]<ma[0]) ) {veer = 1;}
   
   //веер вниз
   if( (ma[4]>ma[3]) && (ma[3]>ma[2]) && (ma[2]>ma[1]) && (ma[1]>ma[0]) ) {veer =-1;}
   
   return;  
}
//=========================================================================
//если правильный веер расширяется из очень узкого источника, то это "горн"
int ophorn_bull(int b)
{
   double ma5, ma4, ma3, ma2, ma1;
   
   double rast_i, rast_b;
   
   int i;
   
   //считываем скользящие средние на баре b
   ma1 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,b);
   ma2 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,b);
   ma3 = iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE,b);
   ma4 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,b);
   ma5 = iMA(NULL,0,233,0,MODE_EMA,PRICE_CLOSE,b);
   
   //если это правильный веер вверх
   if( (ma5<ma4) && (ma4<ma3) && (ma3<ma2) && (ma2<ma1) )
   {
      rast_b = ma1 - ma5;
      
      //начинаем просмотр пучка скользящих средних назад от точки b
      for(i=(b+1); i<(b+300); i++)
      {
         //считываем значения МА
         ma1 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,i);
         ma2 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,i);
         ma3 = iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE,i);
         ma4 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,i);
         ma5 = iMA(NULL,0,233,0,MODE_EMA,PRICE_CLOSE,i);
         
         ma1 = NormalizeDouble(ma1,Digits);
         ma2 = NormalizeDouble(ma2,Digits);
         ma3 = NormalizeDouble(ma3,Digits);
         ma4 = NormalizeDouble(ma4,Digits);
         ma5 = NormalizeDouble(ma5,Digits);
         
         //если почти правильный веер сохраняется
         if( ((ma5<=ma3)&&(ma4<=ma3)&&(ma3<=ma2)&&(ma2<=ma1)) || ((ma5<=ma4)&&(ma4<=ma3)&&(ma3<=ma2)&&(ma3<=ma1)) )
         {
            rast_i = MathMax(ma2,ma1) - MathMin(ma5,ma4);
            
            //если веер становится шире, чем в точке bx он нам не подходит
            if(rast_i > (rast_b+2*Point)) {return(0);}
            
            //ищем бар, где веер сходится в узкий источник и возвращаем его   
            if( (rast_i < (YzIst*Point)) && (rast_i < rast_b) ) {return(i);}
         }
         else {return(0);} 
      }     
   }
   
   return(0);   
}
//=========================================================================
//если правильный веер расширяется из очень узкого источника, то это "горн"
int ophorn_bear(int b)
{
   double ma5, ma4, ma3, ma2, ma1;
   
   double rast_i, rast_b;
   
   int i;
   
   //считываем скользящие средние на баре b
   ma1 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,b);
   ma2 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,b);
   ma3 = iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE,b);
   ma4 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,b);
   ma5 = iMA(NULL,0,233,0,MODE_EMA,PRICE_CLOSE,b);
   
   //если это правильный веер вниз
   if( (ma5>ma4) && (ma4>ma3) && (ma3>ma2) && (ma2>ma1) )
   {
      rast_b = ma5 - ma1;
      
      //начинаем просмотр пучка скользящих средних назад от точки b
      for(i=(b+1); i<(b+300); i++)
      {
         //считываем значения МА
         ma1 = iMA(NULL,0,34,0,MODE_EMA,PRICE_CLOSE,i);
         ma2 = iMA(NULL,0,55,0,MODE_EMA,PRICE_CLOSE,i);
         ma3 = iMA(NULL,0,89,0,MODE_EMA,PRICE_CLOSE,i);
         ma4 = iMA(NULL,0,144,0,MODE_EMA,PRICE_CLOSE,i);
         ma5 = iMA(NULL,0,233,0,MODE_EMA,PRICE_CLOSE,i);
         
         ma1 = NormalizeDouble(ma1,Digits);
         ma2 = NormalizeDouble(ma2,Digits);
         ma3 = NormalizeDouble(ma3,Digits);
         ma4 = NormalizeDouble(ma4,Digits);
         ma5 = NormalizeDouble(ma5,Digits);
         
         //если почти правильный веер сохраняется
         if( ((ma5>=ma3)&&(ma4>=ma3)&&(ma3>=ma2)&&(ma2>=ma1)) || ((ma5>=ma4)&&(ma4>=ma3)&&(ma3>=ma2)&&(ma3>=ma1)) )
         {
            rast_i = MathMax(ma5,ma4) - MathMin(ma2,ma1);
            
            //если веер становится шире, чем в точке b он нам не подходит
            if(rast_i > (rast_b+2*Point)) {return(0);}
            
            //ищем бар, где веер сходится в узкий источник и возвращаем его   
            if( (rast_i < (YzIst*Point)) && (rast_i < rast_b) ) {return(i);}
         }
         else {return(0);} 
      }     
   }
   
   return(0);   
}
//=========================================================================
//определение пробоя диапазона для сигнала узости на баре b
int prob_yzk(int b)
{
   double lev_up, lev_dn;
   
   lev_up = High[iHighest(NULL,0,MODE_HIGH,KolBr,(b+1))];
   
   lev_dn = Low[iLowest(NULL,0,MODE_LOW,KolBr,(b+1))];
   
   if( (Open[1]<lev_up) && (Close[1]>lev_up) ) {return(1);}
   
   if( (Open[1]>lev_dn) && (Close[1]<lev_dn) ) {return(-1);}
   
   return(0);
}
//=========================================================================
//есть ли дивергенция сигнал к покупке на баре b (правый минимум индикатора)
int diver_bull(int b)
{
   int i;
   
   double st1, st2, st3, st4, st5, st6, st7, stoh_min, yama1, lw2, lw1;
   
   if(b<4) {return(0);}
   
   st1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-3));
   st2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-2));
   st3 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-1));
   st4 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, b);
   st5 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+1));
   st6 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+2));
   st7 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+3));
   
   //если точка b это яма на индикаторе стохастик
   if((st7>st4)&&(st6>st4)&&(st5>st4))
   {
      if((st4<st3)&&(st3<st2)&&(st2<st1))
      {
         //объявляем ее минимумом
         yama1 = st4;
         
         stoh_min = st4;
         
         //минимальная цена в этой области
         lw1 = Low[iLowest(NULL,0,MODE_LOW,7,(b-3))];
         
         for(i=(b+4); i<300; i++)
         {
            //цена не должна опускаться ниже первого минимума
            if(Low[i]<lw1) {return(0);}
            
            st1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-3));
            st2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-2));
            st3 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-1));
            st4 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, i);
            st5 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+1));
            st6 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+2));
            st7 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+3));
            
            if((st7>st4)&&(st6>st4)&&(st5>st4))
            {
               if((st4<st3)&&(st4<st2)&&(st4<st1))
               {
                  if( (st4<stoh_min) && (i>(b+RastDiv)) ) 
                  {
                     lw2 = Low[iLowest(NULL,0,MODE_LOW,7,(i-3))];
                     
                     if(lw2>lw1) {return(i);}
                  }
                  
                  //правый минимум должен быть ниже всех, кроме левого
                  if(st4<yama1) {return(0);}
               }
            }
            
            if(st4<stoh_min) {stoh_min = st4;}               
         }
      }
   }
   
   return(0);
}
//=========================================================================
//есть ли дивергенция сигнал к продаже на баре b (правый максимум индикатора)
int diver_bear(int b)
{
   int i;
   
   double st1, st2, st3, st4, st5, st6, st7, stoh_max, xolm1, hi2, hi1;
   
   if(b<4) {return(0);}
   
   st1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-3));
   st2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-2));
   st3 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b-1));
   st4 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, b);
   st5 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+1));
   st6 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+2));
   st7 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+3));
   
   //если точка b это холм на индикаторе стохастик
   if((st7<st4)&&(st6<st4)&&(st5<st4))
   {
      if((st4>st3)&&(st3>st2)&&(st2>st1))
      {
         //объявляем ее максимумом
         xolm1 = st4;
         
         stoh_max = st4;
         
         //максимальная цена в этой области
         hi1 = High[iHighest(NULL,0,MODE_HIGH,7,(b-3))];
         
         for(i=(b+4); i<300; i++)
         {
            //цена не должна подниматься выше первого максимума
            if(High[i]>hi1) {return(0);}
            
            st1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-3));
            st2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-2));
            st3 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i-1));
            st4 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, i);
            st5 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+1));
            st6 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+2));
            st7 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, (i+3));
            
            if((st7<st4)&&(st6<st4)&&(st5<st4))
            {
               if((st4>st3)&&(st4>st2)&&(st4>st1))
               {
                  if( (st4>stoh_max) && (i>(b+RastDiv)) ) 
                  {
                     hi2 = High[iHighest(NULL,0,MODE_HIGH,7,(i-3))]; 
                     
                     if(hi2<hi1) {return(i);}
                  }
                  
                  //правый максимум должен быть выше всех, кроме левого
                  if(st4>xolm1) {return(0);}
               }
            }
            
            if(st4>stoh_max) {stoh_max = st4;}               
         }
      }
   }
   
   return(0);
}
//=========================================================================
//анализ стохастика на графике М5 (на текущем графике)
int analyz_stoch()
{
   double st2, st1;
   
   double si2, si1;
   
   //стохастик на барах 3, 2, 1
   st2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, 2);
   st1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_MAIN, 1);
   
   //сигнальная линия на барах 3, 2, 1
   si2 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_SIGNAL, 2);
   si1 = iStochastic(NULL, 0, StohPer, 4, 3, MODE_SMA, 0, MODE_SIGNAL, 1);
   
   //пересечение снизу вверх
   if((st2<si2)&&(st2<StochDn)&&(st1>si1)) {return(1);} 
   
   //пересечение сверху вниз
   if((st2>si2)&&(st2>StochUp)&&(st1<si1)) {return(-1);}  
   
   return(0);  
}
//=========================================================================
//анализ стохастика на графике М15 (поиск пересечения с сигнальной линией + подтверждение движением цены)
//проверяется факт наличия пересечения на баре b М15 в крайней зоне
int cros_big_stoh(int b)
{
   double st3, st2, st1;
   
   double si2, si1;
   
   double op1, cl1;
   
   //стохастик на барах 3, 2, 1 (бар 1 это бар b)
   st3 = iStochastic(NULL, PERIOD_M15, SthBigPr, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+2));
   st2 = iStochastic(NULL, PERIOD_M15, SthBigPr, 4, 3, MODE_SMA, 0, MODE_MAIN, (b+1));
   st1 = iStochastic(NULL, PERIOD_M15, SthBigPr, 4, 3, MODE_SMA, 0, MODE_MAIN, b);
   
   //сигнальная линия на барах 2, 1
   si2 = iStochastic(NULL, PERIOD_M15, SthBigPr, 4, 3, MODE_SMA, 0, MODE_SIGNAL, (b+1));
   si1 = iStochastic(NULL, PERIOD_M15, SthBigPr, 4, 3, MODE_SMA, 0, MODE_SIGNAL, b);
   
   //открытие и закрытие бара 1 на М15
   op1 = iOpen(NULL,PERIOD_M15,1);
   
   cl1 = iClose(NULL,PERIOD_M15,1);
   
   if( (op1 == 0) || (cl1 == 0) ) {return(0);}
   
   //сигнал к покупке
   if((st2<si2)&&(st1>si1)&&(op1<cl1))
   {
      if( (st3<SthBigDn) || (st2<SthBigDn) ) {return(1);}
   }
   
   //сигнал к продаже
   if((st2>si2)&&(st1<si1)&&(op1>cl1))
   {
      if( (st3>SthBigUp) || (st2>SthBigUp) ) {return(-1);}
   }   
   
   return(0);  
}
//=========================================================================
//поиск флета на заданном баре (возвращает количество баров, верх, низ флета)
void poisk_fleta(int b, int &flt_kl, double &flt_up, double &flt_dn)
{
   double ver_fl, niz_fl, nash_razm;
   
   int i, kol;
   
   flt_kl=0; flt_up=0; flt_dn=0;
   
   kol=1;
   
   ver_fl=High[b];
      
   niz_fl=Low[b];
   
   //ищем длинный и узкий участок
   for(i=(b+1); i<(b+500); i++)
   {
      if(High[i]>ver_fl) {ver_fl=High[i];}
      
      if(Low[i]<niz_fl)  {niz_fl=Low[i];}
      
      //если превысили максимальную высоту выходим
      if((ver_fl-niz_fl)>(VisFlet*Point)) {return;}
      
      kol++;
      
      if(kol>MalFlet)
      {
         //наш размах флета (для данного количества баров)
         nash_razm=NormalizeDouble(((kol*KoefYzk)*Point),Digits);
         
         if((ver_fl-niz_fl)<nash_razm) 
         {
            flt_kl = kol;
            
            flt_up = ver_fl;
            
            flt_dn = niz_fl;
            
            return;
         }       
      }
   }
   
   return;
}
//=========================================================================
//есть ли пробой флета на графике М5 (на текущем графике)
int proboy_fleta()
{
   //верхняя и нижняя граница флета
   double v_gr, n_gr;
   
   //количество баров во флете
   int fk;
   
   //ищем флет на баре 2 (пробой баром 1)
   poisk_fleta(2,fk,v_gr,n_gr);
   
   if(fk>0)
   {
      if((Open[1]<v_gr)&&(Close[1]>v_gr)) {return( 1);}
      
      if((Open[1]>n_gr)&&(Close[1]<n_gr)) {return(-1);}
   }
   
   //ищем флет на баре 3, пробой двумя барами (2 и 1)
   poisk_fleta(3,fk,v_gr,n_gr);
   
   if(fk>0)
   {
      if((Open[1]<v_gr)&&(Close[2]>v_gr)&&(Open[1]<Close[1])&&(Open[2]<Close[2])) {return( 1);}
      
      if((Open[1]>n_gr)&&(Close[2]<n_gr)&&(Open[1]>Close[1])&&(Open[2]>Close[2])) {return(-1);}
   }   
   
   return(0); 
}
//=========================================================================
//проверка, есть ли молот на баре br
int opr_molot(int br)
{
   double razm_br, ver_ten, niz_ten;
   
   razm_br = High[br] - Low[br];
   
   ver_ten = High[br] - MathMax(Open[br], Close[br]);
   
   niz_ten = MathMin(Open[br], Close[br]) - Low[br];
   
   if( razm_br > (MolRaz*Point) )
   {
      if( (100*niz_ten) > (BigTen*razm_br) )
      {
         if( (100*ver_ten) < (LitTen*razm_br) )
         {
            return(1);
         }
      }
   
      if( (100*ver_ten) > (BigTen*razm_br)  )
      {
         if( (100*niz_ten) < (LitTen*razm_br)  )
         {
            return(-1);
         }
      }
   }   
   
   return(0);
}
//=========================================================================
//подсчет лотов баев и селов наших ордеров (переведенные в б/у не считаем)
void podschet_orderov(double &ob,double &os)
{
   int i=0, kol=0;
   
   //в начале обнуляем ответы
   ob=0; os=0;
   
   kol=OrdersTotal();
   
   if(kol<1) {return;}

   for(i=0; i<kol; i++) 
   {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if( (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) )
         {
            if(OrderType()==OP_BUY )
            {
               if( (OrderStopLoss()==0) || (OrderStopLoss() < OrderOpenPrice()) )
               {
                  ob=ob+OrderLots();
               }
            }
              

            if(OrderType()==OP_SELL)
            {
               if( (OrderStopLoss()==0) || (OrderStopLoss() > OrderOpenPrice()) )
               {
                  os=os+OrderLots();
               }
            }
         }                       
      }
   }      
   
   return;
}
//=========================================================================
//действия с ордером OP_BUY
void obr_open_buy(int cl_b)
{            
   bool close, modify;
   
   //закрытие во избежание потерь
   if(cl_b==2)
   {
      close = OrderClose(OrderTicket(),OrderLots(),Bid,3,Purple);
      
      if(close == false)
      { 
         Print("Не удалось закрыть ордер OP_BUY код ошибки  ",GetLastError());
      }
      
      return;
   }     
   
   //перевод стоп-лосса в безубыток
   if(StopBy>9)
   {
      if( (OrderStopLoss()==0) || (OrderStopLoss()<OrderOpenPrice()) )
      {
         if( (Bid-StopBy*Point) > (OrderOpenPrice()+ProfBy*Point) )
         {
            modify = OrderModify(OrderTicket(),OrderOpenPrice(),(Bid-StopBy*Point),OrderTakeProfit(),0,Magenta);
            
            if(modify == false)
            {
               Print("Не удалось перевести в безубыток ордер OP_BUY код ошибки  ",GetLastError());
            }
             
            return;
         }
      }
   }
   
   //передвижение тралинг-стопа
   if(DistTral > 9)
   {
      if( (Bid - DistTral*Point) > OrderOpenPrice() )
      {
         if( (Bid - DistTral*Point) > (OrderStopLoss() + StepTral*Point) )
         {
            modify = OrderModify(OrderTicket(),OrderOpenPrice(),(Bid - DistTral*Point),OrderTakeProfit(),0,Red);
            
            if(modify == false)
            {
               Print("Не удалось модифицировать тралинг стоп для ордера OP_BUY код ошибки  ",GetLastError());
            }
             
            return;            
         }
      }
   } 
    
   return;
}
//=========================================================================
//действия с ордером OP_SELL
void obr_open_sell(int cl_s)
{         
    bool close, modify;
   
    //закрытие во избежание потерь
    if(cl_s==2)
    {
        close = OrderClose(OrderTicket(),OrderLots(),Ask,3,Purple);
      
        if(close == false)
        {
            Print("Не удалось закрыть ордер OP_SELL код ошибки  ",GetLastError());
        }
       
        return;
    }    
   
    //перевод в стоп-лосса безубыток
    if(StopBy>9)
    {
       if( (OrderStopLoss()==0) || (OrderStopLoss()>OrderOpenPrice()) )
       {
          if( (Ask+StopBy*Point) < (OrderOpenPrice()-ProfBy*Point) )
          {
             modify = OrderModify(OrderTicket(),OrderOpenPrice(),(Ask+StopBy*Point),OrderTakeProfit(),0,Aqua);
             
             if(modify == false)
             {
                 Print("Не удалось перевести в безубыток ордер OP_SELL код ошибки  ",GetLastError());
             }
              
             return;
          }
       }
    }
    
   //передвижение тралинг-стопа
   if(DistTral > 9)
   {
      if( (Ask + DistTral*Point) < OrderOpenPrice() )
      {
         if( (Ask + DistTral*Point) < (OrderStopLoss() - StepTral*Point) )
         {
            modify = OrderModify(OrderTicket(),OrderOpenPrice(),(Ask + DistTral*Point),OrderTakeProfit(),0,Red);
            
            if(modify == false)
            {
               Print("Не удалось модифицировать тралинг стоп для ордера OP_SELL код ошибки  ",GetLastError());
            }
             
            return;            
         }
      }
   }       
                    
    return;
}
//=========================================================================
//Закрытие и модификация ордеров нашей валюты
void perebor_orderov(int zak_b, int zak_s)
{
   int type=0,kol=0,i=0;
   
   kol=OrdersTotal();
   
   if(kol<1) {return;}
   
   for(i=0; i<kol; i++)
   {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
      {
         if( (OrderSymbol() == Symbol()) && (OrderMagicNumber() == Magic) )
         {
            type=OrderType();
            
            if(type==OP_BUY)        
            {
               obr_open_buy(zak_b);
               continue;
            }
            
            
            if(type==OP_SELL)        
            {
               obr_open_sell(zak_s);
               continue;
            }             
         }
      }
   }
      
   return;
}
//=========================================================================
//установка ордера OP_BUY
void ystanovit_buy(string prich, int kf)
{
   double sl, tp, lt;
   
   int tiket;
   
   sl = 0;
   
   if(StopLos > 9)
   {
      sl = Bid-StopLos*Point;
   }
   
   tp = 0;
         
   if(TeikPro > 9)
   {
      tp = Ask+TeikPro*Point;
   }
   
   lt = LotPoz;
   
   if(kf > 1)
   {
      //если совпало несколько сигналов - открываем двойной лот
      lt = lt*2;
   }
   
   tiket = OrderSend(Symbol(),OP_BUY,lt,Ask,3,sl,tp,prich,Magic,0,Blue);
   
   if(tiket < 0)
   {
      Print("Не удалось открыть ордер OP_BUY код ошибки  ",GetLastError());
   }
   
   return;
}
//=========================================================================
//установка ордера OP_SELL
void ystanovit_sel(string prich, int kf)
{
   double sl, tp, lt;
   
   int tiket;
   
   sl = 0;
   
   if(StopLos > 9) 
   {
      sl = Ask+StopLos*Point;
   }
   
   tp = 0;     
         
   if(TeikPro > 9) 
   {
      tp=Bid-TeikPro*Point;
   }
   
   lt = LotPoz;
   
   if(kf > 1) 
   {
      //если совпало несколько сигналов - открываем двойной лот
      lt = lt*2;
   }
   
   tiket = OrderSend(Symbol(),OP_SELL,lt,Bid,3,sl,tp,prich,Magic,0,Red);
   
   if(tiket < 0)
   {
      Print("Не удалось открыть ордер OP_SELL код ошибки  ",GetLastError());
   }   
   
   return;
}
//=========================================================================
//THE END :)