extern int SL=88, TP=10;
 int K;

 extern double LOT=0.03;
 
 bool flag=false;

 bool New_Bar=false;
 
 
//---------------------------------------------------------------------------------------------------------------------------------------------
int init()
  { return(0);   }

int deinit()
  { return(0);   }
//---------------------------------------------------------------------------------------------------------------------------------------------
int start()
{K=(SL/10)+1;
 bool plus_signal=false, minus_signal=false;
 double Cur_Bar_0, Cur_Bar_1, Cur_Bar_2,N,N_minus,Price,Price_minus;
 int Min_Dist,Delta,Delta_minus;
 
 Comment ("Баланс депозита ", AccountBalance(),
          "\nПлечо ", AccountLeverage());
 
 //----------------------------------------------------БЛОК СРАБАТЫВАНИЯ КОНТРОРДЕРА-----------------------------------------------------------
 if ( OrderSelect(0, SELECT_BY_POS, MODE_TRADES)==true) // Блок выставления и срабатывания контрордера
 { if (OrdersTotal()==1 && OrderType()==OP_BUY) 
        {OrderSend(Symbol(),OP_SELLSTOP,OrderLots()*K, OrderStopLoss(),2, OrderStopLoss()+SL*Point, OrderStopLoss()-TP*Point); flag=true; return;} //если сработал отложенный ордер, здесь выставляем контрордер на продажу
   if (OrdersTotal()==1 && OrderType()==OP_SELL)  // если сработал ранее отложенный ордер на покупку, выставляем отложенный на продажу
        {OrderSend(Symbol(),OP_BUYSTOP,OrderLots()*K, OrderStopLoss(),2, OrderStopLoss()-SL*Point, OrderStopLoss()+TP*Point); flag=true; return;}
      if (OrdersTotal()==1 && (OrderType()==OP_SELLSTOP || OrderType()==OP_BUYSTOP) && flag==true)
        { OrderDelete(OrderTicket()); flag=false; } 
         if (OrdersTotal()==2) return; 
     
 }  
 //--------------------------------------------------------------------------------------------------------------------------------------------
 
 
 
   Fun_New_Bar();                                         // Обращение к ф-ии регистрации появления нового бара
   if (New_Bar==false)  return;                                  // Если бар не новый..     
   
   Min_Dist=MarketInfo(Symbol(),MODE_STOPLEVEL);
   
   Cur_Bar_0=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
   Cur_Bar_1=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
   Cur_Bar_2=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,2);
 
 plus_signal=(Cur_Bar_0>=Cur_Bar_1 && Cur_Bar_1>Cur_Bar_2 && Cur_Bar_2<=0 && Cur_Bar_0>=0 && Cur_Bar_1>=0);
 minus_signal=(Cur_Bar_0<=Cur_Bar_1 && Cur_Bar_1<Cur_Bar_2 && Cur_Bar_2>=0 && Cur_Bar_0<=0 && Cur_Bar_1<=0);

 N=NormalizeDouble(High[1]+2*Point,Digits);
 N_minus=NormalizeDouble(Low[1]-2*Point,Digits);
 Price=NormalizeDouble(Ask,Digits);
 Price_minus=NormalizeDouble(Bid,Digits);
 Delta=MathAbs((N-Price)/Point);
 Delta_minus=MathAbs((N_minus-Price_minus)/Point);
 

 

  if ((plus_signal==true || minus_signal==true) && (OrdersTotal()==0 || (OrdersTotal()==1 && (OrderType()==OP_SELLSTOP || OrderType()==OP_BUYSTOP))) ) 
       { if (OrdersTotal()==1) 
          {OrderSelect(0,SELECT_BY_POS,MODE_TRADES); OrderDelete(OrderTicket());}
         
         if (plus_signal==true) fun_open_plus_1 (Price, N, Delta, Min_Dist);  
         if (minus_signal==true)fun_open_minus_1(Price_minus, N_minus, Delta_minus, Min_Dist);  
       return; }
//---------------------------------------------------------------------------------------------------------------------------------------------  
// блок модификации отложенных ордеров
  if (OrderSelect(0, SELECT_BY_POS, MODE_TRADES)==true && (OrderType()==OP_BUYSTOP || OrderType()==OP_SELLSTOP))
   { 
      if (OrderType()==OP_BUYSTOP) modif_plus(Price, N, Delta, Min_Dist);
      if (OrderType()==OP_SELLSTOP) modif_min(Price_minus,N_minus,Delta_minus,Min_Dist);
   }
return;
}
//---------------------------------------------------------------------------------------------------------------------------------------------
void Fun_New_Bar()                              // Ф-ия обнаружения нового бара 
{                                                  // нового бара  
   static datetime New_Time=0;                     // Время текущего бара  
   if ( OrderSelect(0, SELECT_BY_POS, MODE_TRADES)==true && (OrderType()==OP_BUY || OrderType()==OP_SELL))    return; // выход из функции, если сработал отложенный ордер
 
   New_Bar=false; 
                                                    // Нового бара нет  
   if(New_Time!=Time[0])                           // Сравниваем время    
   {  New_Time=Time[0];                            // Теперь время такое    
      New_Bar=true;                                // Поймался новый бар    
   }
}

//---------------------------------------------------------------------------------------------------------------------------------------------

void fun_open_plus_1 (double Price, double N, int Delta, int Min_Dist)    // ф-я, открывает отложенный ордер на покупку

{  double STOP,Profit,Enter;
  
  
  
      if (Price>N) { OrderSend(Symbol(),OP_BUYSTOP,LOT,Price+Min_Dist*Point,2,Price+Min_Dist*Point-SL*Point,Price+Min_Dist*Point+TP*Point); return;}
     
      if (Delta<=Min_Dist)
        {  
          
           Enter=NormalizeDouble(Price+Point+Min_Dist*Point,Digits);
           STOP=NormalizeDouble(Enter-SL*Point,Digits);
           Profit=NormalizeDouble(Enter+TP*Point,Digits);
           OrderSend(Symbol(),OP_BUYSTOP,LOT,Enter,2,STOP,Profit); // Выставляем ордер с поправкой на диапозон заморозки
        }  
         else 
        { 
           
            OrderSend(Symbol(),OP_BUYSTOP,LOT,N,2,N-SL*Point,N+TP*Point); // Если цена выше диапозона заморозки, выставляем обычный отложенный ордер
        } 
return;
}
//---------------------------------------------------------------------------------------------------------------------------------------------
void fun_open_minus_1 (double Price_minus, double N_minus, int Delta_minus, int Min_Dist)    // ф-я, открывает отложенный ордер на продажу 

{ double STOP,Profit,Enter;
   
  
  
  if (Price_minus<N_minus)  
   { OrderSend(Symbol(),OP_SELLSTOP,LOT,Price_minus-Min_Dist*Point,2,Price_minus-Min_Dist*Point+SL*Point,Price_minus-Min_Dist*Point-TP*Point); return;}
     
      if (Delta_minus<=Min_Dist)
        {  
           Enter=NormalizeDouble(Price_minus-Point-Min_Dist*Point,Digits);
           STOP=NormalizeDouble(Enter+SL*Point,Digits);
           Profit=NormalizeDouble(Enter-TP*Point,Digits);
           OrderSend(Symbol(),OP_SELLSTOP,LOT,Enter,2,STOP,Profit); // Выставляем ордер с поправкой на диапозон заморозки
        }  
         else 
           {  
              OrderSend(Symbol(),OP_SELLSTOP,LOT,N_minus,2,N_minus+SL*Point,N_minus-TP*Point); // Если цена выше диапозона заморозки, выставляем обычный отложенный ордер
           } 
return;
}
//---------------------------------------------------------------------------------------------------------------------------------------------
// функция модификации отложенного ордера BUY_STOP

void modif_plus(double Price, double N, int Delta, int Min_Dist)
{ bool a=0,d=0;
  double Price_NEW,SL_NEW,TP_NEW;

 
 
 a=NormalizeDouble(Ask+Point+Min_Dist*Point,Digits)==NormalizeDouble(OrderOpenPrice(),Digits);
 d=NormalizeDouble(N,Digits)==NormalizeDouble(OrderOpenPrice(),Digits);
 
 if (a==true || d==true) Alert ("Ордер OP_BUYSTOP не нуждается в модификации");
   else 
    { if (Delta<=Min_Dist || Ask>N)
                {   
                 Price_NEW=NormalizeDouble(Ask+Point+Min_Dist*Point,Digits);
                
                 SL_NEW=NormalizeDouble(Price_NEW-SL*Point,Digits);
                 TP_NEW=NormalizeDouble(Price_NEW+TP*Point,Digits);                                
                 OrderModify (OrderTicket (), Price_NEW, SL_NEW, TP_NEW , 0); // Модифицируем ордер с поправкой на диапозон заморозки
                }  
              else 
                  {  
                SL_NEW=NormalizeDouble(N-SL*Point,Digits);
                TP_NEW=NormalizeDouble(N+TP*Point,Digits);
                 OrderModify (OrderTicket(), N, SL_NEW, TP_NEW,0);               
                
                  }
    } 
return;
}
//---------------------------------------------------------------------------------------------------------------------------------------------
// функция модификации отложенного ордера OP_SELLSTOP

void modif_min (double Price_minus, double N_minus, int Delta_minus, int Min_Dist)
{ bool a=0,d=0;
  double Price_NEW,SL_NEW,TP_NEW;

 
 
 a=NormalizeDouble(Bid-Point-Min_Dist*Point,Digits)==NormalizeDouble(OrderOpenPrice(),Digits);
 d=NormalizeDouble(N_minus,Digits)==NormalizeDouble(OrderOpenPrice(),Digits);
 
 if (a==true || d==true) Alert ("Ордер OP_SELLSTOP не нуждается в модификации");
   else 
    { if (Delta_minus<=Min_Dist || Bid<N_minus)
                {  
                 Price_NEW=NormalizeDouble(Bid-Point-Min_Dist*Point,Digits);
                 
                 SL_NEW=NormalizeDouble(Price_NEW+SL*Point,Digits); 
                 TP_NEW=NormalizeDouble(Price_NEW-TP*Point,Digits);                             
                 OrderModify (OrderTicket (), Price_NEW, SL_NEW, TP_NEW , 0); // Модифицируем ордер с поправкой на диапозон заморозки
                }  
              else 
                  {  
                SL_NEW=NormalizeDouble(N_minus+SL*Point,Digits);
                TP_NEW=NormalizeDouble(N_minus-TP*Point,Digits);
                 OrderModify (OrderTicket(), N_minus, SL_NEW, TP_NEW,0);               
                
                  }
    } 
return;
}
//---------------------------------------------------------------------------------------------------------------------------------------------