void PutOrder(int type,double price,int mn)
{
   int r=0;
   color clr=Green;
   sl=0;tp=0;

   if(type==OP_SELL || type==OP_SELLSTOP || type==OP_SELLLIMIT)
     {
      clr=Red;
      if(SL>0)
         sl=NormalizeDouble(price+sl,_Digits);
      if(TP>0)
         tp=NormalizeDouble(price-tp,_Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(SL>0)
         sl=NormalizeDouble(price-sl,_Digits);
      if(TP>0)
         tp=NormalizeDouble(price+tp,_Digits);
     }

   r=OrderSend(NULL,type,Lot(),NormalizeDouble(price,_Digits),Slip,sl,tp," ",0,clr);
   return;
}
//+------------------------------------------------------------------+
//|   Подсчёт отложенных ордеров Ветви Sell                          |
//+------------------------------------------------------------------+
int CountLimVS(int type)
{
     int count=0;
   	
     for(int i=OrdersTotal()-1; i>=0; i--)
         {
   		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==SMB)
				if(OrderType()==type)
					 count++;
      	}
  return(count);
}
//+------------------------------------------------------------------+
//|     Счётчик  всех  открытых  ордеров  ветки  Sell                |
//+------------------------------------------------------------------+
int CountOpenVS()
{
	int count=0;
	
   for(int i=OrdersTotal()-1; i>=0; i--)
      {
		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==SMB)
			if(OrderType() == OP_BUY || OrderType() == OP_SELL)
				if(OrderMagicNumber()==MagicSell)
					count++;
   	}
  return(count);
}
//+------------------------------------------------------------------+
//|        Закрытие всех открытых ордеров                            |
//+------------------------------------------------------------------+
void CloseAllOpen()
{
  bool cl;
	
  for(int i=OrdersTotal()-1; i>=0; i--)
     {
		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
			if(OrderSymbol()==SMB && OrderMagicNumber()==MagicSell)
   			{
				if(OrderType()==OP_BUY)
   				{
					RefreshRates();
					cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,Digits),Slip,clrWhite);
   				}
				if(OrderType()==OP_SELL)
   				{
					RefreshRates();
					cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,Digits),Slip,clrWhite);
   				}
   			}
   	}
}
//+------------------------------------------------------------------+
//|       Удаление всех отложенных ордеров                           |
//+------------------------------------------------------------------+
void DelLimOrderVS()
{
	for(int i=OrdersTotal()-1; i>=0; i--)
   	{
		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
			if(OrderSymbol()==SMB && OrderMagicNumber()==MagicSell)
				if(OrderType() == OP_BUYSTOP || OrderType() == OP_SELLSTOP || OrderType() == OP_BUYLIMIT || OrderType() == OP_SELLLIMIT)
					if(!OrderDelete(OrderTicket()))
						Print(__FUNCTION__," Ошибка № ",GetLastError()," при удалении отложенного ордера");
   	}
}
//+------------------------------------------------------------------+
//|       Профит всех открытых ордеров                               |
//+------------------------------------------------------------------+
double AllProfit()
{
   	double profit=0;
      for(int i=OrdersTotal()-1; i>=0; i--)
        {
   		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
   			if(OrderSymbol()==SMB && OrderMagicNumber()==MagicSell)
   				if(OrderType()== OP_BUY || OrderType()== OP_SELL)
   					profit+=OrderProfit()+OrderSwap()+OrderCommission();
        }
  return(profit);
}
//+------------------------------------------------------------------+

#property strict

extern double         Loss           = 590;          // убыток в валюте
extern double         Profit         = 2;            // профит в валюте
extern int            SL             = 1;            // Stop Loss
extern int            TP             = 1;            // STake Profit
extern int            Distance       = 4;            // дистанция отложек
extern int            StepTrail      = 7;            // шаг трала отложек
extern double         Lots           = 0.8;          // лот
extern double         LotK           = 2.5;          // увеличение лота
extern double         MaxLot         = 14.7;         // максимальный лот
extern int            Slip           = 30;           // проскальзывание
extern int            MagicSell      = 1961;         // магик продажа
//---
double buy=0,sel=0,MinLevel,PNT,dist, TralStep,sl,tp;
int    numVS=0;
string SMB;
double BuyPriceMax,SelPriceMin,LotBuyMax,LotSellMin,
       op,lt,pr,ProfitBuy,ProfitSell,StartLot;
int    tk,SchBuy,SchSell,SchRyn;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
	  SMB  = Symbol();
	  PNT  = MarketInfo(SMB,MODE_POINT);
 return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
     MinLevel = (int)MarketInfo(NULL,MODE_STOPLEVEL);
	  TralStep = StepTrail*PNT;
	  dist     = (Distance + MinLevel)*PNT;
     sl       = (SL + MinLevel)*PNT;
     tp       = (TP + MinLevel)*PNT;
     
// При достижении профита или убытка больше уствновленных, закрываются все ордера, удаляются все отложки и начинается новый цикл.
// Эта функция, фрктически, является и SL и более ТР для ордеров. Так проще, лучше и эффективнее, чем SL и ТР отдельных ордеров.
     
     if((AllProfit()>Profit && Profit!=0) || (-AllProfit()>Loss && Loss!=0))
        {
   	  CloseAllOpen();          // закрытие всех открытых ордеров
   	  DelLimOrderVS();        // удаление всех отложек
   	  }
     // ----------------------------------- Установка стартового ордера -----------------------------------------------
     
// Если нет открытых ордеров, то удаляются все отложенные ордера и открывается OP_SELL ордер стартовым лотом. Начало цикла.
// Дальше обвязывается тремя ордерами. На Distance ниже SellStop, выше на Distance SellLimit и на Distance*1.5 ордер BuyStop.
// Все ордера выставляются также стартовым лотом.
   
     if(CountOpenVS()<1)                                            // Если открытых ордеров ветки Sell (VS)нет
        {
        DelLimOrderVS();                                            // удаление всех отложенных ордеров ветки Sell 
        
        PutOrder(OP_SELL, Bid, MagicSell);                          // открываем Sell ордер ветки Sell
      	 
        if(CountLimVS(OP_SELLLIMIT)<1)                              // если нет SellLimit ордеров ветки Sell,
           {
           sel = NormalizeDouble(Bid+MinLevel+dist,_Digits);
           PutOrder(OP_SELLLIMIT, sel, MagicSell);                  // выставляем SellLimit ордер
           }
        if(CountLimVS(OP_BUYSTOP)<1)                                // а если нет BuyStop ордеров ветки Sell,
       	  {
           buy = NormalizeDouble(Ask+(MinLevel+dist)*1.5,_Digits);
           PutOrder(OP_BUYSTOP,buy, MagicSell);                     // выставляем BuyStop ордер
           }
        if(CountLimVS(OP_SELLSTOP)<1)                               // если нет SellStop ордеров ветки Sell,
           {
           sel = NormalizeDouble(Bid-MinLevel-dist,_Digits);
           PutOrder(OP_SELLSTOP, sel, MagicSell);                   // выставляем SellLimit ордер
           }
        numVS = CountOpenVS(); 
        }
     //------------------------------------ открытие последующих ордеров ---------------------------------------------
     
// Если количество открытых ордеров OP_SELL стало больше, значит сработала какая-то SELL отложка.
// Удаляем все оставшиеся(юся)отложки(у).
// Дальше обвязывается тремя ордерами. На Distance ниже SellStop стартовым лотом умноженном на LotK, 
// выше на Distance выставляем SellLimit  стартовым лотом и на Distance*1.5 ордер BuyStop стартовым лотом.
     
     if(numVS<CountOpenVS())              // Если увеличелось количество открытых ордеров ветки Sell,
        {
        DelLimOrderVS(); 
        }                     // удаляем все отложки ветки Sell.
}
//+------------------------------------------------------------------+
//|      Определение цены последнего открытого ордера ветви Sell     | 
//+------------------------------------------------------------------+
double LastOrderPriceVS()
{      
	double   price = 0;
	datetime time  = 0;
	
	for(int i=0; i<=OrdersTotal()-1; i++)
   	{
		if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
			if(OrderSymbol()==SMB && OrderMagicNumber()==MagicSell)
				if(OrderType()==OP_SELL)
					if(time < OrderOpenTime())
   					{
						price = OrderOpenPrice();
						time = OrderOpenTime();
   					}
   	}
	return(price);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+

Сразу предупреждаю эти коды для тестера чтобы проверить стратегию, на реальной торговле будут глючить