double BuyOrderLossLess() //--- Расчет безубтка для ордеров на покупку
   {
    double boll;
    int i;
    double l=0,pl=0;
    double tv=MarketInfo(Symbol(), MODE_TICKVALUE);
    for(i=0;i<OrdersTotal();i++)
      {
       if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
         {
          if(OrderType()==OP_BUY)
            {
             l=l+OrderLots();
             pl+=(OrderOpenPrice()-NormalizeDouble((OrderSwap()+OrderCommission())/OrderLots()/tv*Point,Digits))*OrderLots();
            }
         }
      }
    if(l>0 && pl>0) boll=NormalizeDouble(pl/l,Digits); else boll=0;
    return(boll);
   }

double SellOrderLossLess() //--- Расчет безубытка для ордеров на продажу
   {
    double soll;
    int i;
    double l=0,pl=0;
    double tv=MarketInfo(Symbol(), MODE_TICKVALUE);
    for(i=0;i<OrdersTotal();i++)
      {
       if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
         {
          if(OrderType()==OP_SELL)
            {
             l=l+OrderLots();
             pl+=(OrderOpenPrice()+NormalizeDouble((OrderSwap()+OrderCommission())/OrderLots()/tv*Point,Digits))*OrderLots();
            }
         }
      }
    if(l>0 && pl>0) soll=NormalizeDouble(pl/l,Digits); else soll=0;
    return(soll);
   }

bool SetBuyOrderStopLoss(double sl)  //--- Установка SL для открытых ордеров на покупку
   {
    bool sbosl=false;
    int i;
    for(i=0;i<OrdersTotal();i++)
      {
       if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
         {
          if(OrderType()==OP_BUY)
            {
             if(OrderStopLoss()!=sl && OrderStopLoss()<sl) 
             if(OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0)) sbosl=true; 
             else { Print(OrderTicket(),": BUY SL OrderModify failed with error #",GetLastError()); }
            }
         }     
      }
    return(sbosl);
   }

bool SetSellOrderStopLoss(double sl)  //--- Установка SL для открытых ордеров на продажу
   {
    bool ssosl=false;
    int i;
    for(i=0;i<OrdersTotal();i++)
      {
       if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
         {
          if(OrderType()==OP_SELL)
            {
             if(OrderStopLoss()!=sl && ((OrderStopLoss()>sl && OrderStopLoss()!=0) || OrderStopLoss()==0)) 
             if(OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0)) ssosl=true; 
             else { Print(OrderTicket(),": SELL SL OrderModify failed with error #",GetLastError()); }
            }
         }     
      }
    return(ssosl);
   }

<code>string sy=IIFs(AllSymbols, "", NULL);</code>

<code>SimpleTrailing(sy, OP_BUY, Magic);</code>

<code>SimpleTrailing(sy, -1, Magic);</code>

<code>SimpleTrailing(sy, OP_SELL, Magic);</code>

//+------------------------------------------------------------------+
//|                                BuySell31 Трал группы ордеров.mq4 |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                              http://www.mql5.com |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//|                                BuySell31 Трал группы ордеров.mq4 |
//|                                              Copyright 2020, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
/*
http://zakaz.opentraders.ru/55004.html#comment152604

Трал группы ордеров
Нужен трал стоплосса группы ордеров.
То есть находятся отдельно селловые, отдельно баевые открытые ордера.
При переходе общего профита, допустим, селловых ордеров, в плюс столько-то, включается трал, 
который тащит на определённом расстоянии от цены стоплосс, общий для этих ордеров.
То же самое отдельно и с баевыми.

вот готовый вариант. открываешь сеть бай и селл советником и он тралит по очереди то и другое: 
www.opentraders.ru/downloads/2702/
*/
#property copyright "Copyright 2020, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"

#property version   "1.00"
#property strict
#property copyright "Ким Игорь В. aka KimIV"
#property link  "http://www.kimiv.ru"
#property strict

//--- Inputs
extern double Lots       = 0.1;      // лот
extern int StopLoss      = 2000;     // лось
extern int TakeProfit    = 3000;     // язь
extern int TrailingStop  = 300;      // трал
extern int Slip          = 30;       // реквот
//extern int Magic         = 123;      // магик
//------- Внешние параметры советника -----------------------------------------+
extern string _P_Expert = "---------- Параметры советника";
extern bool   AllSymbols    = True;    // Следить за позициями всех символов
extern int    Magic         = -1;      // Идентификатор позиций
extern int    TrailingStart = 3;       // Начальный уровень трала
extern bool   BuyTrail      = True;    // Тралить покупки
extern int    TStop_Buy     = 50;      // Размер трала в пунктах для покупок
extern bool   SellTrail     = True;    // Тралить продажи
extern int    TStop_Sell    = 35;      // Размер трала в пунктах для продаж
extern int    TrailingStep  = 3;       // Шаг трала в пунктах
extern bool   ShowComment   = True;    // Показывать комментарий

//------- Параметры исполнения торговых приказов ------------------------------+
extern string _P_Performance = "---------- Параметры исполнения";
extern bool   UseSound     = True;          // Использовать звуковой сигнал
extern string SoundSuccess = "expert.wav";  // Звук успеха
extern string SoundError   = "timeout.wav"; // Звук ошибки
extern int    NumberOfTry  = 200;           // Количество торговых попыток

//------- Глобальные переменные советника -------------------------------------+
bool   gbDisabled   = False;           // Флаг блокировки советника
bool   gbNoInit     = False;           // Флаг неудачной инициализации
color  clModifyBuy  = Aqua;            // Цвет значка модификации покупки
color  clModifySell = Tomato;          // Цвет значка модификации продажи

//------- Подключение внешних модулей -----------------------------------------+
#include <stdlib.mqh>
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
   PutButton("B",100,160,"BUY");
   PutButton("S",100,120,"SELL");
   PutButton("C",100,80,"CLOSE");
//---
//---
    gbNoInit=False;
  if (!IsTradeAllowed()) {
    Message("Для нормальной работы советника необходимо\n"+
            "Разрешить советнику торговать");
    gbNoInit=True; return(0);
  }
  if (!IsLibrariesAllowed()) {
    Message("Для нормальной работы советника необходимо\n"+
            "Разрешить импорт из внешних экспертов");
    gbNoInit=True; return(0);
  }
  if (!IsTesting()) {
    if (IsExpertEnabled()) Message("Советник будет запущен следующим тиком");
    else Message("Отжата кнопка \"Разрешить запуск советников\"");
  }
  OnTick();
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectDelete(0,"B");
   ObjectDelete(0,"S");
   ObjectDelete(0,"C");
   if (!IsTesting()) Comment("");
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutButton(string name,int x,int y,string text)
  {
   ObjectCreate(0,name,OBJ_BUTTON,0,0,0);
//--- установим координаты кнопки
   ObjectSetInteger(0,name,OBJPROP_XDISTANCE,x);
   ObjectSetInteger(0,name,OBJPROP_YDISTANCE,y);
//--- установим размер кнопки
   ObjectSetInteger(0,name,OBJPROP_XSIZE,80);
   ObjectSetInteger(0,name,OBJPROP_YSIZE,30);
//--- установим угол графика, относительно которого будут определяться координаты точки
   ObjectSetInteger(0,name,OBJPROP_CORNER,3);
//--- установим текст
   ObjectSetString(0,name,OBJPROP_TEXT,text);
//--- установим шрифт текста
   ObjectSetString(0,name,OBJPROP_FONT,"Arial");
//--- установим размер шрифта
   ObjectSetInteger(0,name,OBJPROP_FONTSIZE,9);
//--- установим цвет текста
   ObjectSetInteger(0,name,OBJPROP_COLOR,Red);
//--- установим цвет фона
   ObjectSetInteger(0,name,OBJPROP_BGCOLOR,White);
//--- установим цвет границы
   ObjectSetInteger(0,name,OBJPROP_BORDER_COLOR,Blue);
//--- скроем (true) или отобразим (false) имя графического объекта в списке объектов
   ObjectSetInteger(0,name,OBJPROP_HIDDEN,false);
//--- установим приоритет на получение события нажатия мыши на графике
   ObjectSetInteger(0,name,OBJPROP_ZORDER,0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type,double price)
  {
   int r=0;
   color clr=Green;
   double sl=0,tp=0;

   if(type==1 || type==3 || type==5)
     {
      clr=Red;
      if(StopLoss>0)
         sl=NormalizeDouble(price+StopLoss*_Point,_Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price-TakeProfit*_Point,_Digits);
     }

   if(type==0 || type==2 || type==4)
     {
      clr=Blue;
      if(StopLoss>0)
         sl=NormalizeDouble(price-StopLoss*_Point,_Digits);
      if(TakeProfit>0)
         tp=NormalizeDouble(price+TakeProfit*_Point,_Digits);
     }

   r=OrderSend(NULL,type,Lots,NormalizeDouble(price,_Digits),Slip,sl,tp,"",Magic,0,clr);
   return;
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void CloseAll(int ot=-1)
  {
   bool cl;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0 && (ot==0 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Bid,_Digits),Slip,White);
              }
            if(OrderType()==1 && (ot==1 || ot==-1))
              {
               RefreshRates();
               cl=OrderClose(OrderTicket(),OrderLots(),NormalizeDouble(Ask,_Digits),Slip,White);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void Trailing()
  {
   bool mod;
   double all=0,count=0,sl=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()<2)
              {
               all+=OrderOpenPrice()*OrderLots();
               count+=OrderLots();
              }
           }
        }
     }

   if(count>0)
      all=NormalizeDouble(all/count,_Digits);

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() || OrderMagicNumber()==Magic)
           {
            if(OrderType()==OP_BUY)
              {
               if(Bid-all>TrailingStop*_Point)
                 {
                  if(OrderStopLoss()<Bid-TrailingStop*_Point)
                    {
                     sl=NormalizeDouble(Bid-TrailingStop*_Point,_Digits);
                     if(OrderStopLoss()!=sl)
                        mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0,Yellow);
                    }
                 }
              }

            if(OrderType()==OP_SELL)
              {
               if(all-Ask>TrailingStop*_Point)
                 {
                  if((OrderStopLoss()>(Ask+TrailingStop*_Point)) || (OrderStopLoss()==0))
                    {
                     sl=NormalizeDouble(Bid+TrailingStop*_Point,_Digits);
                     if(OrderStopLoss()!=sl)
                        mod=OrderModify(OrderTicket(),OrderOpenPrice(),sl,OrderTakeProfit(),0,Yellow);
                    }
                 }
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//-----
   if (gbDisabled) {
    Message("Критическая ошибка! Советник ОСТАНОВЛЕН!"); return;
  }
  if (gbNoInit) {
    Message("Не удалось инициализировать советник!"); return;
  }
  if (ShowComment) {
    Comment(IIFs(AllSymbols, "AllSymbols  ", "")
           ,"Magic=", IIFs(Magic<0, "Любой", DoubleToStr(Magic, 0)), "  "
           ,"TrailingStart=", DoubleToStr(TrailingStart, 0), " п.  "
           ,"TStop_Buy=", DoubleToStr(TStop_Buy, 0), " п.  "
           ,"TStop_Sell=", DoubleToStr(TStop_Sell, 0), " п.  "
           ,"TrailingStep=", DoubleToStr(TrailingStep, 0), " п.  "
           );
  } else Comment("");

  string sy=IIFs(AllSymbols, "", NULL);
  
  if(BuyTrail)SimpleTrailing(sy, OP_BUY, Magic);
  if(SellTrail)SimpleTrailing(sy, OP_SELL, Magic);
//----- 
/* 
   if(TrailingStop>0)
      Trailing();
*/
   if(ObjectGetInteger(0,"B",OBJPROP_STATE)==1)
     {
      PutOrder(0,Ask);
      ObjectSetInteger(0,"B",OBJPROP_STATE,false);
     }

   if(ObjectGetInteger(0,"S",OBJPROP_STATE)==1)
     {
      PutOrder(1,Bid);
      ObjectSetInteger(0,"S",OBJPROP_STATE,false);
     }

   if(ObjectGetInteger(0,"C",OBJPROP_STATE)==1)
     {
      CloseAll();
      ObjectSetInteger(0,"C",OBJPROP_STATE,false);
     }
  }
//+------------------------------------------------------------------+

//+----------------------------------------------------------------------------+
//|                                                                            |
//|  ПОЛЬЗОВАТЕЛЬСКИЕ ФУНКЦИИ                                                  |
//|                                                                            |
//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Возвращает наименование торговой операции                      |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    op - идентификатор торговой операции                                    |
//+----------------------------------------------------------------------------+
string GetNameOP(int op) {
  switch (op) {
    case OP_BUY      : return("Buy");
    case OP_SELL     : return("Sell");
    case OP_BUYLIMIT : return("BuyLimit");
    case OP_SELLLIMIT: return("SellLimit");
    case OP_BUYSTOP  : return("BuyStop");
    case OP_SELLSTOP : return("SellStop");
    default          : return("Unknown Operation");
  }
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 18.07.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
color IIFc(bool condition, color ifTrue, color ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.02.2008                                                     |
//|  Описание : Возвращает одно из двух значений взависимости от условия.      |
//+----------------------------------------------------------------------------+
string IIFs(bool condition, string ifTrue, string ifFalse) {
  if (condition) return(ifTrue); else return(ifFalse);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 01.09.2005                                                     |
//|  Описание : Вывод сообщения в коммент и в журнал                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    m - текст сообщения                                                     |
//+----------------------------------------------------------------------------+
void Message(string m) {
  Comment(m);
  if (StringLen(m)>0) Print(m);
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 28.11.2006                                                     |
//|  Описание : Модификация одного предварительно выбранного ордера.           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    pp - цена установки ордера                                              |
//|    sl - ценовой уровень стопа                                              |
//|    tp - ценовой уровень тейка                                              |
//|    ex - дата истечения                                                     |
//+----------------------------------------------------------------------------+
void ModifyOrder(double pp=-1, double sl=0, double tp=0, datetime ex=0) {
  bool   fm;
  color  cl=IIFc(OrderType()==OP_BUY
              || OrderType()==OP_BUYLIMIT
              || OrderType()==OP_BUYSTOP, clModifyBuy, clModifySell);
  double op, pa, pb, os, ot;
  int    dg=MarketInfo(OrderSymbol(), MODE_DIGITS), er, it;

  if (pp<=0) pp=OrderOpenPrice();
  if (sl<0 ) sl=OrderStopLoss();
  if (tp<0 ) tp=OrderTakeProfit();
  
  pp=NormalizeDouble(pp, dg);
  sl=NormalizeDouble(sl, dg);
  tp=NormalizeDouble(tp, dg);
  op=NormalizeDouble(OrderOpenPrice() , dg);
  os=NormalizeDouble(OrderStopLoss()  , dg);
  ot=NormalizeDouble(OrderTakeProfit(), dg);

  if (pp!=op || sl!=os || tp!=ot) {
    for (it=1; it<=NumberOfTry; it++) {
      if (!IsTesting() && (!IsExpertEnabled() || IsStopped())) break;
      while (!IsTradeAllowed()) Sleep(5000);
      RefreshRates();
      fm=OrderModify(OrderTicket(), pp, sl, tp, ex, cl);
      if (fm) {
        if (UseSound) PlaySound(SoundSuccess); break;
      } else {
        er=GetLastError();
        if (UseSound) PlaySound(SoundError);
        pa=MarketInfo(OrderSymbol(), MODE_ASK);
        pb=MarketInfo(OrderSymbol(), MODE_BID);
        Print("Error(",er,") modifying order: ",ErrorDescription(er),", try ",it);
        Print("Ask=",pa,"  Bid=",pb,"  sy=",OrderSymbol(),
              "  op="+GetNameOP(OrderType()),"  pp=",pp,"  sl=",sl,"  tp=",tp);
        Sleep(1000*10);
      }
    }
  }
}

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 11.09.2008                                                     |
//|  Описание : Сопровождение позиций простым тралом                           |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   ( ""  - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   ( -1  - любая позиция)                  |
//|    mn - MagicNumber                ( -1  - любой магик)                    |
//+----------------------------------------------------------------------------+
void SimpleTrailing(string sy="", int op=-1, int mn=-1) {
  double po, pp;
  int    i, k=OrdersTotal();

  if (sy==NULL) sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if ((OrderSymbol()==sy || sy=="") && (op<0 || OrderType()==op)) {
        po=MarketInfo(OrderSymbol(), MODE_POINT);
        if (mn<0 || OrderMagicNumber()==mn) {
          if (OrderType()==OP_BUY) {
            pp=MarketInfo(OrderSymbol(), MODE_BID);
            if (pp-OrderOpenPrice()>=TrailingStart*po) {
              if (OrderStopLoss()<pp-(TStop_Buy+TrailingStep-1)*po) {
                ModifyOrder(-1, pp-TStop_Buy*po, -1);
              }
            }
          }
          if (OrderType()==OP_SELL) {
            pp=MarketInfo(OrderSymbol(), MODE_ASK);
            if (OrderOpenPrice()-pp>=TrailingStart*po) {
              if (OrderStopLoss()>pp+(TStop_Sell+TrailingStep-1)*po || OrderStopLoss()==0) {
                ModifyOrder(-1, pp+TStop_Sell*po, -1);
              }
            }
          }
        }
      }
    }
  }
}
//+----------------------------------------------------------------------------+