При чем здесь шаблон? Просто набор готовых функций. С такими темпами заказов, по-другому не получится. А вот на счет «выдумывать и заморачиваться за бесплатно не охота» тут я соглашусь. А кому сильно то охота? Готовые функции кроме явных плюсов, имеют и минусы. Люди разучаются думать. Некогда.

Минимум изменений и + виртуальные SL и ТР.

//+------------------------------------------------------------------+
//|       Закрытие части позиции по условию взятии части профита.mq4 |
//|                                      А также виртуальные SL и ТР |
//|                        Copyright 2013, MetaQuotes Software Corp. |
//|                                          http://www.mункцql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2013, MetaQuotes Software Corp."
#property link      "http://www.mункцql5.com"
#property version   "1.00"
#property strict

input double        Lots             = 0.02;      // Лот
static input string ClosePart        = "     - = Настройка частичного закрытия ордеров = -";
input int           StopLoss         = 300;       // Стоп лосс
input int           TakeProfit       = 600;       // Тейк профит
input double        PartCloseLots    = 0.5;       // Сколько закрывать
input int           Slip             = 10;        // Проскальзование
static input int    Magic            = 1961;      // Magic
//---
int    posType       = -1;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   CloseOrder();
}
//+------------------------------------------------------------------+
//| Проверка на условие закрытия PartTakeProfit и само закрытие поз  |
//+------------------------------------------------------------------+
void CloseOrder()
{
    int    ticket;
    double lot = 0;
    
    for(int i=0; i<OrdersTotal(); i++)
      {
      ticket = OrderTicket();
        
      if(!(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))) continue;
      if(OrderSymbol() != Symbol()) continue;
      if(OrderMagicNumber()!=Magic) continue;
      if(OrderType() == OP_BUY)
         {
         if(Bid - OrderOpenPrice() >= StopLoss*Point)   //часть ордера при TP=SL
            {
            lot = NormalizeDouble(MathCeil(OrderLots()*100*PartCloseLots)/100,2);
            ClosePosition(ticket,lot);
            }
         if(Bid - OrderOpenPrice() >= TakeProfit*Point) // весь ордер по ТР
            ClosePosition(ticket,OrderLots());
         if(OrderOpenPrice() - Bid >= StopLoss*Point)   // весь ордер по SL
            ClosePosition(ticket,OrderLots());
         }
      if(OrderType() == OP_SELL)
         {
         if(OrderOpenPrice() - Ask >= StopLoss*Point)   //часть ордера при TP=SL
            {
            lot = NormalizeDouble(MathCeil(OrderLots()*100*PartCloseLots)/100,2);
            ClosePosition(ticket,lot);
            }
         if(OrderOpenPrice() - Ask >= TakeProfit*Point) // весь ордер по ТР
            ClosePosition(ticket,OrderLots());
         if( Ask - OrderOpenPrice()  >= StopLoss*Point) // весь ордер по SL
            ClosePosition(ticket,OrderLots());
         }
       }
}
//+------------------------------------------------------------------+
//| Функция  закрытия позиций                                        |
//+------------------------------------------------------------------+
void ClosePosition(int tic, double lot)
{
   bool closed;
   int lastError=0;

   for(int i=0; i<5; i++)
      {
      double price=MarketInfo(Symbol(),posType==OP_BUY ? MODE_BID : MODE_ASK);
      closed=OrderClose(tic,lot,price,Slip,clrYellow);
      
      if(!closed)
         lastError=GetLastError();
      if(closed)          // Позиция закрыта
         break;           // Выходим из цикла
      if(lastError==4108) // Не верный номер тикета
         break;           // Выходим из цикла
      Sleep(100);
      Print("Close Position retry no: "+IntegerToString(i+2));
      }
}
//+------------------------------------------------------------------+

Скучно, девочки. Неужели никому не интересно. Или я не туда постучался?

Смотрите какая штука вырисовывается.
А добавили только одно правило. А 25% это много или как?
Хотелось бы больше. Мне бы тоже.

Ладно, попробуем дальше продвинуться.

Ну а вдруг.

Стратегия безрисковая, но иногда может потребовать бОльших ресурсов.
Всем нравится слово «безрисковая», но как же паршиво звучит «бОльших».
Вот если бы без него… Вот тогда бы…
Мне самому это слово нравится применительно к слову ДЕПОЗИТ. Про всякие там органы типа языка промолчим. А то вдруг в наши ряды просочились девушки? Ну или девушки постарше. Привет, девчонки.

Но хочется спать спокойно, не волнуясь куда цена пойдет. Лишь бы куда-нибудь пошла. От этого просто зависит сколько заработаешь. Волатильность наш наилучший друг. Тобишь денег тоже хочется. Да я сам такой.
Объективности ради, кто не торгует на бирже, может тоже не волноваться.

Большинство людей, не готовых к такому риску, поднимают лапки кверху. Я их понимаю. Но не одобряю. Думать надо самому, а не чужими извилинами.

Надо сокращать нагрузку на свободную маржу. А как? Первое, что мне пришло в голову, пересчитать лоты. В результате изменения расчета лотности, сходу удалось снизить ее на 25%. При этом вся математика стратегии сохранилась и даже выровнялась. Теперь полностью отпал вопрос: в какую сторону идем? Да пофиг.

Продолжение следует.

Немного упростил. На реале из-за 123 строки работать не будет.

<code>//+------------------------------------------------------------------+
//|                                                 DVA_Martin_9.mq4 |
//|                        Copyright 2016, MetaQuotes Software Corp. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2016, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict
input int TakeProfit          = 326; // профит 
input double K_TP             = 0.8; // Коэффициент увеличкения ТР
input int Step                = 285; // шаг первого ордера
input int Delta               = -13; // добавка к шагу со второго ордера, увеличивает расстояние шага на "дельта" от предыдущего
input double Lot              = 0.01;// первый лот открытия
input double MaximalLot       = 0.6; // максимальный лот, который мы разрешаем
input int DotLot              = 2 ;  // 0-лоты 1,  1-лоты 0.1,  2-лоты 0.01  
input int MaxTrades           = 8;   // максимальное количество ордеров одного направления
input double MultiplicatorLot = 2.1; // умножаем последующие ордера
input int Magic               = 333; // индивидуальный номер, по которому советник видет свои сделки
input int Slippage            = 100; // допустимое проскальзывание на новостях в пунктах
string Expert                 = "Martin_9";
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
int OnInit()
  {

   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Пременные для хранения собранной информации
   int b=0,s=0;
   double BuyMinPrice=0,SelMaxPrice=0,BuyMinLot=0,SelMaxLot=0;
   double LotBuy=0;
   double LotSel=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS))
         if(OrderSymbol()==Symbol())
            if(OrderMagicNumber()==Magic)
              {
               if(OrderType()==OP_BUY)
                 {
                  b++; // Считаем открытые ордера на покупку
                  if(OrderOpenPrice()<BuyMinPrice || BuyMinPrice==0) // Находим нижний бай ордер
                    {
                     BuyMinPrice=OrderOpenPrice(); // Запоминаем его цену
                     BuyMinLot=OrderLots(); // Запоминаем его лот
                    }
                 }
               if(OrderType()==OP_SELL)
                 {
                  s++; // Считаем открытые ордера на продажу
                  if(OrderOpenPrice()>SelMaxPrice) // Находим верхний сел ордер
                    {
                     SelMaxPrice=OrderOpenPrice(); // Запоминаем его цену
                     SelMaxLot=OrderLots(); // Запоминаем его лот
                    }
                 }
              }
// Расчитываем лоты
   if(b==0) // Если нет ордеров используем лот из настроек
      LotBuy=Lot;
   else // Иначе используем свой расчет
      LotBuy=BuyMinLot*MultiplicatorLot;
      if(LotBuy>MaximalLot) LotBuy=MaximalLot;//ограничиваем по максимальному лоту
      LotBuy=NormalizeDouble(LotBuy, DotLot);

   if(s==0)
      LotSel=Lot; // Если нет ордеров используем лот из настроек
   else
      LotSel=SelMaxLot*MultiplicatorLot; // Иначе используем свой расчет
      if(LotSel>MaximalLot) LotSel=MaximalLot;//ограничиваем по максимальному лоту
      LotSel=NormalizeDouble(LotSel, DotLot);

   if(b==0 || (b>0 && b<= MaxTrades && Ask<NormalizeDouble(BuyMinPrice-(Step+Delta*b)*Point(),Digits()))) // Если ордеров нет откроем ордер // Если ордера есть и условие выполнено откроем ордер иным лотом
     {
      if(OrderSend(Symbol(),OP_BUY,LotBuy,Ask,Slippage,0,0,Expert + "-" + (string)b + "-" + (string)Step + "-",Magic,0,clrBlue)<0) // Если ордер не открылся
         Print("Error N ",GetLastError()); // Сообщим об ошибке
     }
   if(s==0 || (s>0 && s<= MaxTrades  && Bid>NormalizeDouble(SelMaxPrice+(Step+Delta*s)*Point(),Digits())))// Если ордеров нет откроем ордер // Если ордера есть и условие выполнено откроем ордер иным лотом
     {
      if(OrderSend(Symbol(),OP_SELL,LotSel,Bid,Slippage,0,0,Expert + "-" + (string)s + "-" + (string)Step + "-",Magic,0,clrRed)<0)  // Если ордер не открылся
         Print("Error N ",GetLastError()); // Сообщим об ошибке
     }
// посчитаем математические формулы средних цен
   double BuyAwerage=0,SelAwerage=0,BuyPrice=0,SelPrice=0,BuyLot=0,SelLot=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS))
         if(OrderSymbol()==Symbol())
            if(OrderMagicNumber()==Magic)
              {
               if(OrderType()==OP_BUY)
                 {
                  BuyPrice+=OrderOpenPrice()*OrderLots(); // добавить к переменной BuyPrice Цена оредра 1 * лот ордера 1
                  BuyLot+=OrderLots(); // суммируем лоты
                 }
               if(OrderType()==OP_SELL)
                 {
                  SelPrice+=OrderOpenPrice()*OrderLots(); // добавить к переменной SelPrice Цена оредра 1 * лот ордера 1
                  SelLot+=OrderLots(); // суммируем лоты
                 }
              }
            double TP=TakeProfit*MathPow(K_TP, b)*Point;  
            BuyAwerage=NormalizeDouble(BuyPrice/BuyLot+TP,Digits()); // Произведем расчет средней цены
            SelAwerage=NormalizeDouble(SelPrice/SelLot-TP,Digits()); // Произведем расчет средней цены 
// ---
   for(int i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS))
         if(OrderSymbol()==Symbol())
            if(OrderMagicNumber()==Magic)
              {
               if(OrderType()==OP_BUY)
                 {
                  if(b==1) // Если ордер один и у него нет тейк профита 
                     if(OrderTakeProfit()==0)
                        if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),NormalizeDouble(OrderOpenPrice()+TakeProfit*Point(),Digits()),0,clrGreen)==false)// Добавим тейк а в случае ошибки сообщим трейдеру
                           Print("Error N ",GetLastError());

                  if(b>1)// Если ордеров больше 1
                     if(OrderTakeProfit()!=BuyAwerage) // И тейк не равен требуемой цене  //?????????????????????????????????????
                        if(Ask<BuyAwerage)// Условия торговли соблюдены
                           if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),NormalizeDouble(BuyAwerage,Digits()),0,clrGreen)==false) // Модифицируем ордер или сообщим об ошибке
                              Print("Error N ",GetLastError());
                 }
               if(OrderType()==OP_SELL)
                 {
                  if(s==1) // Если ордер один и у него нет тейк профита 
                     if(OrderTakeProfit()==0)
                        if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),NormalizeDouble(OrderOpenPrice()-TakeProfit*Point(),Digits()),0,clrGreen)==false)// Добавим тейк а в случае ошибки сообщим трейдеру
                           Print("Error N ",GetLastError());
                  if(s>1)// Если ордеров больше 1
                     if(OrderTakeProfit()!=SelAwerage) // И тейк не равен требуемой цене
                        if(Bid>SelAwerage)// Условия торговли соблюдены
                           if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),NormalizeDouble(SelAwerage,Digits()),0,clrGreen)==false) // Модифицируем ордер или сообщим об ошибке
                              Print("Error N ",GetLastError());
                 }
              }

  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {

  }
//+------------------------------------------------------------------+
</code>

Вместо ТР ставьте локи и эквити будет всегда выше. А смысл только в том, чтобы иметь запас для чего-то рискованного. Иначе свопы будут разъедать вашу незафиксированную прибыль.
Правда, если бы Вы зафиксировались, то риск бы не уменьшился. Но когда эквити выше дэпо, спится спокойнее.

Начертил и не испугался. А вот Вас запугали.



Максимальное количество ордеров на стороне аж пять штук насчитал. Даже разочаровался.

Да… Что-то желающих потратить свои время и умственные силы плохо наблюдается.
Подождем-с мальца. Займусь пока процессом написания.

Добрый вечер, а у кого-то ночь.
В Вас чувствуется живой интерес.
Тема блога — А самим то слабо?..
В любом случае, что бы дать денег за «написать», надо четко проработать формальную часть советника. Вот я и предлагаю тему к обсуждению.
Тем более, что Вы изначально подняли планку сложности. А если подумать.
А если еще учесть, что полных идиотов здесь не обнаружено.
Да и видений решения… Тьма, если подумать. Есть их у меня.
Программист из меня, еще тот, но я учусь. В программировании главное не значки, а то о чем это они. Писать в школе научили, а вот стихи может не каждый. Я вот после Есенина сильно застеснялся.
Эта стратегия необоснованно или специально забыта. Накинули на всех шоры, типа это не то… Это другое. Вот народ и отрыгнул идею. А зря.

Стратегия безрисковая. Как бы не пытались отобрать ваши денежки, а кукиш. Есть один недостаток у нее, отсутствие в резерве дедушки банкира с бесконечным дэпо. Деда нет — лапы кверху. А подумать своими запасами не пробовали?

Цена пусть вечность ходит в канале, нам это не интересно.
Вы давно не в теме. Мысль о том, что можно слить депо на марже уже давно отпугнула даже здравомыслящих. Никто не подумал, что если сапоги дерьмо, то надо брать. Вы плохо слышали за Одесских евреев.

Я могу считать Вас интересантом? Это на счет «обходить».

1. Отложки часто дают ошибку 130. Кроме того, что их все время двигать надо. Журнал и итоги из-за этого плохо читаются.
Надо — цена достигла полосы открываемся и никаких проблем.
2. Шаг усреднения как-то надо уменьшать. Чем больше этих шагов, тем больше вероятность разворота.
3. Если мы открыли уже более двух усредняющих ордеров, значит рынок пошел уже точно против нас.
В связи с тем, что цена все время делает откаты то считаю правильным:
— при получении самым большим ордером какой-то прибыли на откате, превышающей убыток, самого меньшего, закрывать оба. Также можно заложить минимальный профит в пару пунктов. С мыслью, что все это было не зря.
— в итоге мы улучшили по цене начальную позицию, увеличили лот, который заработает больше первоначального, и попутно заработали пару копеек.
4. Судя по картинке, индикатор безбожно рисует. Вместо него лучше взять не перерисовывающий ТМА. Свободно в интернете. Если что, отдам свой. Последний.
5. По той же картинке невооруженным глазом видно, что при достижении средней полосы надо половину ордера закрывать, а вторую переводить в БУ+.
6. Самая главная ошибка трейдера: — Я здесь, что бы заработать.
Ответьте себе на один вопрос: а сколько денег Вы сможете заработать на слитом в ноль депозите. А? Вот именно. Главная задача — сохранить.
Ну,… чтобы было на чем зарабатывать. Жадный теряет все. Есть «акулы», которые не только рассчитывают на нашу человеческую жадность, но и поощряют ее. Например, плечо на шару предоставляют.
7. последний пункт по картинке, греющий больше душу, чем депозит. Когда закрываете все, закрывайте вначале плюсовые ордера. Тогда картинка вместо обвисов дэпо, покажет многорбового верблюда. Как по мне, так эстетичнее.

Если появятся заинтересаны порассуждать, я продолжу.

Продолжим.

Представляю стратегию «Защита Ценового Канала». В дальнейшем ЗЦК.
Это единственная из известных мне математически безрисковая система.
Но есть нюансы.
Нарисовал я ее так. Пардон, не художник. Черные кружочки просто для испуга. Умный человек их не заметит. И неваляшкой давно обозвал. Лет 5 тому, может.



Суть стратегии в следующем.
В точке «0» открыли лот в бай. Цена пошла вверх, заработали. Молодцы.
А если в низ? Прошла цена вниз установленный нами шаг, открываем 2 лота сел. Можно, конечно закрыть бай в надежде что сел перекроет убыток бая и еще заработает. Ну есть похожая стратегия, но сегодня не о ней.
Если цена опять вверх ломанулась? Капризная, как женщина.
Итак, если цена вернулась к верхнему уровню, открываем ордер бай размером лота в 2 раза больше, чем предыдущий сел. Лот = 4.
Ну и маемся себе так туда-сюда, пока цена не отойдет от канала на расстояние, равное его ширине. Ну не может же она… В этот момент наступает безубыток.
Дальше Варианты: закрыли противоположные ордера и тралим прибыль или что-то другое. Это уже выходит за рамки тела основной стратегии и подлежит дополнительному обсуждению.

Спасибо. Забудьте за него пока. Не тратте сил. Будет что нбудь новое, сообщу.

Спасибо.
Как мы с Вами похожи. Усы что ли сбрить?..
Пробуйте, если что, второй вариант.
Да и попробуйте протестировать со старыми переменными. Может там были около нужных.
Удачи.

пятизнак

alex30774, день добрый.
Я не предлагаю рабочий советник. Просто немного изменил представленный здесь. Тестировать даже на КТ для меня проблематично. Предложил заказчику советника проверить, есть ли улучшение. Я смог только проследить разницу в работе на КТ исходника и доработанного. Эффект был очень приличный, но это не по тикам. По тикам на дефолте у меня и родной красноту выдает в журнал. Если Ваша база позволяет сделать подгонку хотя бы за три месяца на тиках и сравнить с дефолтником, был бы вам благодарен. К стати, помогли найти кое какие ошибки. Так что разместил в топике исправленный вариант.

Исправленный, вторая часть.

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int LastOrderType()
  {
   int type=0;

   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==0)
              {
               type=1; //buy
               break;
              }
            if(OrderType()==1)
              {
               type=2; //sell
               break;
              }
           }
        }
     }
   return(type);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
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);
              }
           }
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double AllProfit()
  {
   double profit=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)
               profit+=OrderProfit()+OrderSwap()+OrderCommission();
           }
        }
     }
   return(profit);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double Lot(int type)
{
   double lot=Lots;
   
   if(CountTrades()>0 && type==OP_BUY)
     if (StarVar)
       lot=Lots*MathPow(KLot,CountTrades());//*3/4;
     else
       lot=LastOrderLot(OP_SELL)*KLot;
    //---  
   if(CountTrades()>0 && type==OP_SELL)
     if (StarVar)
       lot=Lots*MathPow(KLot,CountTrades());//*3/4;
     else
       lot=LastOrderLot(OP_BUY)*KLot;

      lot=NormalizeDouble(lot, 2);
      
   if(lot>MaxLot)
      lot=Lots;
   return(lot);
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double LastOrderLot(int type=-1)
{
   datetime time =0;
   double lot=0;
   
   for(int i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
           double   lt = OrderLots();
           datetime cl = OrderOpenTime();
            
            if(OrderType()==OP_BUY  && cl>time)
              {  
              time = cl; 
              lot  = lt;
              }
            if(OrderType()==OP_SELL)
              {
              time = cl; 
              lot  = lt;
              }
           }
   return(NormalizeDouble(lot, 2));
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountOrders(int type)
  {
   int count=0;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()==type)
               count++;
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void DelOrder()
  {
   bool del;
   for(int i=OrdersTotal()-1; i>=0; i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
           {
            if(OrderType()>1)
               del=OrderDelete(OrderTicket());
           }
        }
     }
   return;
  }
//+------------------------------------------------------------------+

Исправленный, с двумя вариантами расчета лота на выбор Старый-новый. И со SL.

<code>//+------------------------------------------------------------------+
//|                                             HedgeMartinStop2.mq4 |
//|                                              Copyright 2021, AM2 |
//|                                      http://www.forexsystems.biz |
//+------------------------------------------------------------------+
#property copyright "Copyright 2021, AM2"
#property link      "http://www.forexsystems.biz"
#property version   "1.00"
#property strict

//--- Inputs
extern double         Loss           = 708;       // убыток в валюте
extern double         Profit         = 18;        // профит в валюте
extern bool           StarVar        = false;     // Старый вариант расчета лота
extern double         Lots           = 1.0;       // лот
extern double         KLot           = 2.5;       // увеличение лота
extern double         OrderSL        = 33;        // Ограничение убытка ордера
extern double         MaxLot         = 12;        // максимальный лот
extern int            Delta          = 22;        // дельта
input ENUM_TIMEFRAMES TF_ATR         = PERIOD_M5; // Тайм Фрейм для ATR
extern int            PerATR         = 21;        // Период ATR
extern double         Level          = 0.0003;    // уровень
extern int            Slip           = 30;        // проскальзывание
extern int            Magic          = 123;       // магик
//---

double buy=0,sel=0;
int num=0;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
 return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   double atr=iATR(Symbol(),TF_ATR,PerATR,0);

   if(AllProfit()>Profit || AllProfit()<-Loss)
     {
      CloseAll();
      DelOrder();
     }

   if(CountTrades()<1 && atr>Level)  // Если ордеров на графике нет ATR стало больше уровня
     {
      if(CountOrders(OP_BUYSTOP)<1)  // то, если нет Buy Stop ордеров
        {
         PutOrder(OP_BUYSTOP, buy);
         buy=NormalizeDouble(Bid+Delta*_Point,_Digits);
        }

      if(CountOrders(OP_SELLSTOP)<1)
        {
         PutOrder(OP_SELLSTOP,sel);
         sel=NormalizeDouble(Bid-Delta*_Point,_Digits);
        }
     }

// открытие последующих ордеров
   if(num!=CountTrades())
     {
      if(LastOrderType()==1)
        {
         DelOrder();
         if(CountOrders(5)<1)
            PutOrder(5,sel);
        }

      if(LastOrderType()==2)
        {
         DelOrder();
         if(CountOrders(4)<1)
            PutOrder(4,buy);
        }
      num=CountTrades();
     }
/*   Comment("\n Profit: ",DoubleToString(AllProfit(),2),
           "\n Last Order Type: ",LastOrderType(),
           "\n Count Trades: ",CountTrades());*/
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PutOrder(int type, double price=0)
  {
   int r=0;
   color clr=clrNONE;
   double lot=0,SL=0;
   double sl = OrderSL*Point;
//   double sl = Delta*4*KLot*Point;

   if(type==OP_SELLSTOP)
     {
     clr=clrRed;
     lot=Lot(OP_SELL);
     if(OrderSL>0)
        SL=NormalizeDouble(price+sl,Digits);
      else SL=0;
     }
   if(type==OP_BUYSTOP)
     {
     clr=clrBlue;
     lot=Lot(OP_BUYSTOP);
     if(OrderSL>0)
        SL=NormalizeDouble(price-sl,Digits);
      else SL=0;
     }

   r=OrderSend(Symbol(),type,lot,NormalizeDouble(price,Digits),Slip,SL,0,"",Magic,0,clr);
   return;
  }//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountTrades()
  {
   int count=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)
               count++;
           }
        }
     }
   return(count);
  }
</code>