Сам хренею. Думал ошибка в коде. Не нашел. В некоторых режимах торгует туды-сюды. А чаше — продажи. Менял очередность в коде. Не влияет. Такое чувство, что цена никак не может догнать безубыток.

Вторая часть для склейки.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   	if (last_open>=iTime(NULL, TF, 0)) 
   	   return; 
   	else
   	   {
         TradeMap();
                        
         if (pr>ProfitClose)                                     
            CloseAll();
         //---   
         if(b>MaxOrdersLimit)
            if(OrderClose (BuyPriceMaxTic, BuyPriceMaxLot, Bid , Slippage, clrBlue)) 
         if(s>MaxOrdersLimit)
            if(OrderClose (SelPriceMinTic, SelPriceMinLot, Ask , Slippage, clrRed)) 
         //---   
   	   open  = iOpen (symb,TF,1);
   	   close = iClose(symb,TF,1);
   	   high  = iHigh (symb,TF,1);
   	   low   = iLow  (symb,TF,1);
   	   
   	   if (close>open)
   	      PutOrder(OP_BUY);
   	   if (close<open)
   	      PutOrder(OP_SELL);
   	   if (close==open)
   	      {
   	      if (high-open > open-low)
      	      PutOrder(OP_SELL);
   	      if (high-open < open-low)
      	      PutOrder(OP_BUY);
   	      }
   	   last_open=iTime(NULL, TF, 0);
   	   }
}
//+------------------------------------------------------------------+
//|       Function                                                   |
//+------------------------------------------------------------------+
bool PutOrder(int dir)
{
   	op  = NP((dir==OP_BUY)?Ask:Bid); // цена открытия
      lot = AccountFreeMargin()*Risk/100/MarketInfo(Symbol(), MODE_MARGINREQUIRED);
      //-------------------------------------------------------------//
      if(lot>MaximalLots)      
         lot=MaximalLots;
      
      lot=NL(lot);
      
      if(!ValidLot(lot))
         return(false);
      //-------------------------------------------------------------//
     	int ticket = OrderSend(Symbol(), dir, lot, op, int(Slippage), 0, 0, NULL, MagicNumber);
   	
   	if (ticket<=0) 
   	   { 
   	   Print("OrderSend "+Symbol()+" lot="+DoubleToString(lot, 2)+"  error "+string(GetLastError())); 
   	   return(false);      // выходим при ошибке
   	   }
   	return(true);
}
//+------------------------------------------------------------------+
bool ValidLot(double volume)
{
      //--- минимально допустимый объем для торговых операций
      double min_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
      if(volume<min_volume)
         return(false);
   
      //--- максимально допустимый объем для торговых операций
      double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
      if(volume>max_volume)
         return(false);
   
      //--- получим минимальную градацию объема
      double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);
   
      int ratio=(int)MathRound(volume/volume_step);
      if(MathAbs(ratio*volume_step-volume)>0.0000001)
         return(false);
   
   return(true);
}

//+------------------------------------------------------------------+
bool CloseAll()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
               if(OrderProfit()>0)
                 {
                 if(OrderType()==OP_BUY)
                   if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                     Sleep(500);
                 if(OrderType()==OP_SELL)
                   if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                     Sleep(500);
                 }
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
//               if(OrderProfit()<=0)
                    {
                    if(OrderType()==OP_BUY)
                      if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                        Sleep(500);
                    if(OrderType()==OP_SELL)
                      if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                        Sleep(500);
                    }
   return true;
}
//+------------------------------------------------------------------+
double NP(double d) { double TickSize=MarketInfo(Symbol(), MODE_TICKSIZE); if (TickSize==0) TickSize=1; return ND(MathRound(d/TickSize)*TickSize); }
//+------------------------------------------------------------------+
double ND(double d, int n=-1) 
{ 
      if (n<0) 
         return NormalizeDouble(d, Digits); 
    return NormalizeDouble(d, n); 
}
//+------------------------------------------------------------------+
double NL(double _lot) // нормализация лота
{
	double LotStep=MarketInfo(Symbol(), MODE_LOTSTEP);
	int k=0;
	if (LotStep<=0.001) k=3; else if (LotStep<=0.01) k=2; else if (LotStep<=0.1) k=1; // шаг лота

	double MinLot=MarketInfo(Symbol(), MODE_MINLOT);
	double MaxLot=MarketInfo(Symbol(), MODE_MAXLOT);
	return ND(MathMin(MaxLot, MathMax(MinLot, _lot)), k); // венули нормализованный лот
}
//+------------------------------------------------------------------+
void TradeMap()
{
      BuyPriceMax=0;BuyPriceMin=0;BuyPriceMaxLot=0;BuyPriceMinLot=0;
      SelPriceMin=0;SelPriceMax=0;SelPriceMinLot=0;SelPriceMaxLot=0;
      BuyPriceMaxTic=0;BuyPriceMinTic=0;SelPriceMaxTic=0;SelPriceMinTic=0;
      BuyLotsSum=0;SelLotsSum=0;WeighBuy=0;WeighSell=0;
      op=0;lt=0;tp=0;pr=0;
      BuyBU=0;SelBU=0;FullBU=0;
      tk=0;b=0;s=0;
      
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                 {
                  op=NormalizeDouble(OrderOpenPrice(),Digits());
                  lt=NormalizeDouble(OrderLots(),2);
                  tk=OrderTicket();
                  
                  pr += OrderProfit() + OrderCommission() + OrderSwap();

                  if(OrderType()==OP_BUY)
                    {
                     b++;
                     BuyLotsSum += lt;
                     WeighBuy   += lt*op;
                     
                     if(op>BuyPriceMax || BuyPriceMax==0)
                       {
                        BuyPriceMax    = op;
                        BuyPriceMaxLot = lt;
                        BuyPriceMaxTic = tk;
                       }
                     if(op<BuyPriceMin || BuyPriceMin==0)
                       {
                        BuyPriceMin    = op;
                        BuyPriceMinLot = lt;
                        BuyPriceMinTic = tk;
                       }
                    }
                  // ===
                  if(OrderType()==OP_SELL)
                    {
                     s++;
                     SelLotsSum += lt;
                     WeighSell  += lt*op;
                     
                     if(op>SelPriceMax || SelPriceMax==0)
                       {
                        SelPriceMax    = op;
                        SelPriceMaxLot = lt;
                        SelPriceMaxTic = tk;
                       }
                     if(op<SelPriceMin || SelPriceMin==0)
                       {
                        SelPriceMin    = op;
                        SelPriceMinLot = lt;
                        SelPriceMinTic = tk;
                       }
                    }
                 }
              //---
              if (BuyLotsSum - SelLotsSum != 0) 
                 FullBU = (WeighBuy - WeighSell)/(BuyLotsSum - SelLotsSum);
}
//+------------------------------------------------------------------+

Блин, кажись комп издох. Тестер не тестирует. Даже старье. Перезагрузил терминал. Пофиг. НАКИДАЛ ПРОСТЕНЬКИЙ. проверить не могу. ВРОДЕ ПО ЭНШУЮ. Первые тесты по ценам открытия были один в один с тестами по тикам.

Пробуйте, а я пока займусь компом.

Удачи.

//+------------------------------------------------------------------+
//|                                                   KAE Rebate.mq4 |
//|                                            kvashnin007@gmail.com |
//+------------------------------------------------------------------+
#property version   "1.00"
#property strict
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
//---
input ENUM_TIMEFRAMES TF                  = PERIOD_CURRENT; // Тайм Фрейм для свечей. 0-текущий чарта.
input double          ProfitClose         = 0.3;            // Минимальный профит ($) для закрытия ордеров. 
input int             MaxOrdersLimit      = 7;              // Close Limit - функция оставляет к-во ордеров в каждом направлении.
//---      
input double          Risk                = 0.5;            // Авто лот, 0- выкл.
input double          MaximalLots         = 2.56;           // Maximal Lot 
//---
input int             MagicNumber         = 1961;           // Magic Number 
input int             Slippage            = 30;             // Slippage (in pips)
//---
datetime last_open=0;    
double   op,lt,tp;
int      tk,b,s;
int      iB=0;
double   FullBU,BuyBU,SelBU,StartLots, pr=0;
double   StepLot, lot;
int      BuyPriceMaxTic,BuyPriceMinTic,SelPriceMaxTic,SelPriceMinTic,CountHist=0;
double   BuyPriceMax=0,BuyPriceMin=0,BuyPriceMaxLot=0,BuyPriceMinLot=0,
         SelPriceMin=0,SelPriceMax=0,SelPriceMinLot=0,SelPriceMaxLot=0;
double   StopEquity=0, OldEquity=0, Equity, AE, AB;
double   OldFreeMarg=0, FreeMarg;
double   OldLasso=0;
double   BuyLotsSum,SelLotsSum,WeighBuy,WeighSell;
double   open, close, high, low;
string   symb;  
int      LastCloseType;
double   LastCloseLot, LastCloseProfit;
//+------------------------------------------------------------------+
int OnInit()
{
   	last_open = iTime(NULL,TF,1);
   	symb      = Symbol();
   return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}

Я бы добавил:
Красная линия — сел до серой.
Перелом красной вверх — бай до перелома линии вниз.
Перелом зеленой вниз — сел до перелома вверх.

Перелом — это не обязательно рост вверх, а на следующей свече падение вниз.
Можно использовать замедление роста-падения с заданным процентом замедления.

Этот метод высокочастотной торговли мой. Идея простая.
Ордеров множество, прибыль так себе, а основной заработок на Ribаte.
Без напряга за месяц >15 лотов. При лоте 0.01. Прибыль не большая — процентов десять при просадке до 20%. А основной заработок на Ribаte. Если не лень, посчитайте 50% только спреда. Сумма прелюбопытнейшая.

Кстати на эту тему открыл топик. Добро пожаловать.

kvashnin007.opentraders.ru/131192.html

А это за какой советник речь?..

Jimirami, я не работал над советником. Просто посмотрев работу того, что Шаман дал. и заметил точки улучшения. В настоящий момент даже то, что получил, не работает. Даже толком не помню, что хотелось изменить. Писал Сергею, а он не заинтересовался. На этом и порешили. Помню, что вероятности событий распределены были не верно. Это мы считаем, что фифти -фифти. А по факту не более 33%. Надо было менять ММ.

А у тебя что? мой вариант работает?

А зачем Мартин? Сорок ордеров по 0.01 — это всего 0.40 лота.

Напомню: текущий Эквити показывает нам, сколько манейS останется на депозите, если мы все закроем, выключив таки свет.

Открытие ордеров. Серьезная штука.
Тестирование — не менее серьезная штука.
Предлагаю сложить серьезности не деля на два.

Например. TF М5. Свеча закрылась вверх. Открываем ордер Buy. Следующая закрылась вверх — OP_BUY. Закрылась вниз — Sell. А покупки, например, закрыли.

Что мы имеем?
Каждые пять минут ордер. Умножили на килограммы — сумасшедшие деньги. НО…
Мы можем тестировать по ценам открытия. Быстро, а итог, что по тикам.

Идея в моем понимании не плохая, но надо над ММ подумать. Сейчас или в ходе первых тестирований. Тут важно не набрать много ордеров. Чтоб до цугундера в виде кочерги не добаловать.

Как тебе такое, дорогой Илан?

Что-то не фонтанирует. Добавил еще индюка на выбор. Трал Эквити от CMILION. Пробуйте.

www.opentraders.ru/downloads/3846/

День добрый!
Пардон. Перезалил.

Вторая склейка

//---   
   if(Metod==Shaman || Metod==ShamanSmart)
     {
      if(Signal()==OP_BUY && Ask<FullBU && Ask<=BuyPriceMin-PointOrderStep*Point())
         if((b==0) || (b>0 && Ask<=BuyPriceMin-PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_BUY,NormalizeDouble(BuyLot,2),NormalizeDouble(Ask,Digits()),Slippage,0,0," ",MagicNumber,0,clrBlue)<0)
               Print("OrderSend error #",GetLastError());
   
      if(Signal()==OP_SELL && Bid>FullBU && Bid>=SelPriceMax+PointOrderStep*Point())
         if((s==0) || (s>0 && Bid>=SelPriceMax+PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_SELL,NormalizeDouble(SelLot,2),NormalizeDouble(Bid,Digits()),Slippage,0,0," ",MagicNumber,0,clrRed)<0)
               Print("OrderSend error #",GetLastError());
     }
//*************************************************************//
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
               op=NormalizeDouble(OrderOpenPrice(),Digits());
               tp=NormalizeDouble(OrderTakeProfit(),Digits());
               lt=NormalizeDouble(OrderLots(),2);
               tk=OrderTicket();

               if(OrderType()==OP_BUY && b==1 && tp==0)
                  if(!OrderModify(tk,op,OrderStopLoss(),NormalizeDouble(Ask+TakeProfit*Point(),Digits()),0,clrNONE))
                     Print("OrderModify error #",GetLastError());

               if(OrderType()==OP_BUY && b>=CountAverage)
                 {
                  if(tk==BuyPriceMaxTic || tk==BuyPriceMinTic)
                     if(Bid<AwerageBuyPrice && tp!=AwerageBuyPrice)
                        if(!OrderModify(tk,op,OrderStopLoss(),AwerageBuyPrice,0,clrNONE))
                           Print("OrderModify error #",GetLastError());

                  if(tk!=BuyPriceMaxTic && tk!=BuyPriceMinTic && tp!=0)
                     if(!OrderModify(tk,op,0,0,0,clrNONE))
                        Print("OrderModify error #",GetLastError());
                 }
                 
               if(OrderType()==OP_SELL && s==1 && tp==0)
                  if(!OrderModify(tk,op,OrderStopLoss(),NormalizeDouble(Bid-TakeProfit*Point(),Digits()),0,clrNONE))
                     Print("OrderModify error #",GetLastError());

               if(OrderType()==OP_SELL && s>=CountAverage)
                 {
                  if(tk==SelPriceMaxTic || tk==SelPriceMinTic)
                     if(Ask>AwerageSelPrice && tp!=AwerageSelPrice)
                        if(!OrderModify(tk,op,OrderStopLoss(),AwerageSelPrice,0,clrNONE))
                           Print("OrderModify error #",GetLastError());

                  if(tk!=SelPriceMaxTic && tk!=SelPriceMinTic && tp!=0)
                     if(!OrderModify(tk,op,0,0,0,clrNONE))
                        Print("OrderModify error #",GetLastError());
                 }
              }
              //---
              double Prof = GetProfit();
              
              if((Prof>=LevelStopProfit && LevelStopProfit!=0) || (-Prof>=LevelStopLoss && LevelStopLoss!=0))
                CloseAll();
                
              if(LevelBU>0) 
                 BU();
}
//************************************************************************************************/
bool ValidLot(double volume)
{
//--- минимально допустимый объем для торговых операций
   double min_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
   if(volume<min_volume)
      return(false);

//--- максимально допустимый объем для торговых операций
   double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
   if(volume>max_volume)
      return(false);

//--- получим минимальную градацию объема
   double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);

   int ratio=(int)MathRound(volume/volume_step);
   if(MathAbs(ratio*volume_step-volume)>0.0000001)
      return(false);

   return(true);
}
//************************************************************************************************/
/*СИГНАЛ*/
//------------------------------------------------------------------	
int Signal()                   // Создаем функцию получения сигнала на указанном ТФ и баре
{
      iB=1; if(SignalOnCurent) iB=0;
      
      double KVN_0=iCustom(NULL,0,INDUK1,PeriodLR, PerMADelta, 0, iB);
      double KVN_1=iCustom(NULL,0,INDUK1,PeriodLR, PerMADelta, 0, iB+1);
      
      if (KVN_1>=0 &&  KVN_0<=0) 
         return OP_SELL;
       
      if (KVN_1<=0 &&  KVN_0>=0) 
         return OP_BUY;
	return -1;                   // Иначе нет сигнала. Возвращаем в int Signai () -1 (никаких сигналов)
}
//************************************************************************************************
double GetProfit()
{  
   double Profit=0;
     
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              Profit += OrderProfit() + OrderCommission() + OrderSwap();
   return (Profit);
}
//************************************************************************************************
bool CloseAll()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              if(OrderType()==OP_BUY)
                if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                  Sleep(500);
              if(OrderType()==OP_SELL)
                if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                  Sleep(500);
              }
   return true;
}
//************************************************************************************************
bool BU()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              double  sl = 0;
                      tp = OrderTakeProfit();
                      op = OrderOpenPrice();
                      lt = OrderLots();
              double _lt = NormalizeDouble(lt/2,2);
                     
                     
              if(!ValidLot(_lt)) continue;
                           
              if(OrderType()==OP_BUY && Bid >= op+LevelBU*Point)
                {
                sl = NBU(OP_BUY,op);
                if(sl == OrderStopLoss())continue;
                 
                if(OrderModify(OrderTicket(),op,sl,0,0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Bid,Slippage))
                    Sleep(500);
                }
              //---
              if(OrderType()==OP_SELL &&  Ask <= op-LevelBU*Point)
                {
                sl = NBU(OP_SELL,op);
                if(sl == OrderStopLoss())continue;
                 
                if(OrderModify(OrderTicket(),op,sl,0,0,clrNONE))
                  if(!OrderClose(OrderTicket(),_lt,Ask,Slippage))
                    Sleep(500);
                }
              }
   return true;
}
//************************************************************************************************
double NBU(int dir, double oop) // Нормализация цены стоплоса
{
   double BU = LevelBU; 

	if (BU==0) return 0;
	
	double StopLvl=MarketInfo(Symbol(), MODE_STOPLEVEL)*Point;
	double pr=NP((dir==OP_BUY)?Bid:Ask);
	
	if (dir==OP_BUY) 
	   { 
	   double _sl=oop-BU*Point;
	   return NP(MathMin(_sl, pr-StopLvl)); 
	   }
	if (dir==OP_SELL) 
	   { 
	   double _sl=oop+BU*Point;
	   return NP(MathMax(_sl, pr+StopLvl)); 
	   }
	return 0;
}
//************************************************************************************************
double NP(double d) 
{
       double TickSize=MarketInfo(Symbol(), MODE_TICKSIZE); 
       
       if (TickSize==0) 
         TickSize=1; 
    return ND(MathRound(d/TickSize)*TickSize); 
}
//************************************************************************************************
double ND(double d, int n=-1) 
{ 
      if (n<0) 
         return NormalizeDouble(d, Digits); 
    return NormalizeDouble(d, n); 
}
//************************************************************************************************
double NL(double lot) // нормализация лота
{
	double LotStep=MarketInfo(Symbol(), MODE_LOTSTEP);
	int k=0;
	if (LotStep<=0.001) k=3; else if (LotStep<=0.01) k=2; else if (LotStep<=0.1) k=1; // шаг лота

	double MinLot=MarketInfo(Symbol(), MODE_MINLOT);
	double MaxLot=MarketInfo(Symbol(), MODE_MAXLOT);
	return ND(MathMin(MaxLot, MathMax(MinLot, lot)), k); // венули нормализованный лот
}
//************************************************************************************************

Индюк KAE_KVN_U_Dif3_MT4 www.opentraders.ru/downloads/3845/ закинуть в папку индикаторов.

Советник, конечно же, не для продаж. Есть над чем работать. Но интересен. Своими выкрутасами.
Впрочем, крайний вариант. Часть первая.

//+------------------------------------------------------------------+
//|                                           KAE Shaman NEW v.2.mq4 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property strict
#define INDUK1 "KVN_KAE_U_Dif3"
//---
enum ENUM_Metod
  {
   Normal       = 0,  
   Shaman       = 1,  
   ShamanSmart  = 2     
  };
input ENUM_Metod      Metod               = Shaman;    // Metod Open - тип работы советника, метод открытия ордеров.
input bool            Agressor            = false;     // Agressor - функция влияет только на расчет ордеров и работает всегда.
input bool            RebateOn            = false;     // Программа для возврата Спреда.
input int             CloseLim            = 0;         // Close Limit - функция оставляет к-во ордеров в каждом направлении.
input int             CountAverage        = 2;         // Count Average - к-во ордеров при котором начинается усреднение.
//---      
input double          Risk                = 0.5;       // Авто лот, 0- выкл.
input double          StartLot            = 0.01;      // Start lot
input double          CoeffLots           = 1.1;       // Coeff. Lots - коэффициент мартингейла
input double          MaximalLots         = 2.56;      // Maximal Lot 
//--
input int             TakeProfit          = 273;       // Take Profit (in pips)
input int             PointOrderStep      = 63;        // Point order step (in pips)
input int             MinimalProfit       = 37;        // Minimal profit for close Average orders (in pips)
//---
input int             PeriodLR            = 7;        // Период LR
input int             PerMADelta          = 3;        // Период сглаживания
input bool            SignalOnCurent      = false;
//---      
input double          LevelStopLoss       = 0;
input double          LevelStopProfit     = 0;
input int             LevelBU             = 0;
//---
input int             MagicNumber         = 1961;      // Magic Number 
input int             Slippage            = 30;        // Slippage (in pips)
//---
double SellBuff;
double BuyBuff;
double ShortSig;
double LongSig;
double op,lt,tp;
int    tk,b,s;
int    iB=0;
double BuyPriceMax=0,BuyPriceMin=0,BuyPriceMaxLot=0,BuyPriceMinLot=0,
       SelPriceMin=0,SelPriceMax=0,SelPriceMinLot=0,SelPriceMaxLot=0;
double FullBU,BuyBU,SelBU,StartLots;
double StepLot;
double StopEquity=0, OldEquity=0, Equity;
double OldFreeMarg=0, FreeMarg;
double OldLasso=0;
int    BuyPriceMaxTic,BuyPriceMinTic,SelPriceMaxTic,SelPriceMinTic,CountHist=0;
double BuyLotsSum,SelLotsSum,WeighBuy,WeighSell;
//************************************************************************************************/
int OnInit()
{
      string Symb    = Symbol();                                // Финансовый инструм.
      double One_Lot = MarketInfo(Symb,MODE_MARGINREQUIRED);    // Стоим. 1 лота
      double LotVal  = MarketInfo(Symb, MODE_TICKVALUE);        //стоимость 1 пункта для 1 лота
      double margin  = MarketInfo(Symbol(),MODE_MARGINREQUIRED);
             StepLot = MarketInfo(Symb, MODE_LOTSTEP);          // шаг изменения лота
     Comment("");
  return(INIT_SUCCEEDED);
}
//************************************************************************************************/
void OnTick()
{
   if (CountHist!=OrdersTotal())                // Если изменилось количество открытых ордеров.
      {
      CountHist=OrdersTotal();
      
      BuyPriceMax=0;BuyPriceMin=0;BuyPriceMaxLot=0;BuyPriceMinLot=0;
      SelPriceMin=0;SelPriceMax=0;SelPriceMinLot=0;SelPriceMaxLot=0;
      BuyPriceMaxTic=0;BuyPriceMinTic=0;SelPriceMaxTic=0;SelPriceMinTic=0;
      BuyLotsSum=0;SelLotsSum=0;WeighBuy=0;WeighSell=0;
      op=0;lt=0;tp=0;
      BuyBU=0;SelBU=0;FullBU=0;
      tk=0;b=0;s=0;
      
      for(int i=OrdersTotal()-1;i>=0;i--)
         if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
            if(OrderMagicNumber()==MagicNumber)
               if(OrderSymbol()==Symbol())
                 {
                  op=NormalizeDouble(OrderOpenPrice(),Digits());
                  lt=NormalizeDouble(OrderLots(),2);
                  tk=OrderTicket();
                  if(OrderType()==OP_BUY)
                    {
                     b++;
                     BuyLotsSum += lt;
                     WeighBuy   += lt*op;
                     
                     if(op>BuyPriceMax || BuyPriceMax==0)
                       {
                        BuyPriceMax    = op;
                        BuyPriceMaxLot = lt;
                        BuyPriceMaxTic = tk;
                       }
                     if(op<BuyPriceMin || BuyPriceMin==0)
                       {
                        BuyPriceMin    = op;
                        BuyPriceMinLot = lt;
                        BuyPriceMinTic = tk;
                       }
                    }
                  // ===
                  if(OrderType()==OP_SELL)
                    {
                     s++;
                     SelLotsSum += lt;
                     WeighSell  += lt*op;
                     
                     if(op>SelPriceMax || SelPriceMax==0)
                       {
                        SelPriceMax    = op;
                        SelPriceMaxLot = lt;
                        SelPriceMaxTic = tk;
                       }
                     if(op<SelPriceMin || SelPriceMin==0)
                       {
                        SelPriceMin    = op;
                        SelPriceMinLot = lt;
                        SelPriceMinTic = tk;
                       }
                    }
                 }
      }              
      //---------------------------------------------------------------------------------------------
              if(b>CloseLim && CloseLim!=0)
                if(OrderClose (BuyPriceMaxTic, BuyPriceMaxLot, Bid , Slippage, clrBlue)) 
                  return;
                
              if(s>CloseLim && CloseLim!=0)
                if(OrderClose (SelPriceMinTic, SelPriceMinLot, Ask , Slippage, clrRed)) 
                  return;
              //---
              if (BuyLotsSum - SelLotsSum != 0) 
                 FullBU = (WeighBuy - WeighSell)/(BuyLotsSum - SelLotsSum);
               //---    
              if (RebateOn)                                               
                 {                
                 if (GetProfit()>0)
                    CloseAll();
                 }
//*************************************************************//
   double   AwerageBuyPrice=0,AwerageSelPrice=0;
   if(b>=CountAverage) AwerageBuyPrice=NormalizeDouble
         ((BuyPriceMax*BuyPriceMaxLot+BuyPriceMin*BuyPriceMinLot)/(BuyPriceMaxLot+BuyPriceMinLot)+MinimalProfit*Point(),Digits());
   if(s>=CountAverage) AwerageSelPrice=NormalizeDouble
         ((SelPriceMax*SelPriceMaxLot+SelPriceMin*SelPriceMinLot)/(SelPriceMaxLot+SelPriceMinLot)-MinimalProfit*Point(),Digits());
//*************************************************************//
   StartLots=StartLot;
   
   if (Risk>0) 
      StartLots=AccountFreeMargin()*Risk/100/MarketInfo(Symbol(), MODE_MARGINREQUIRED); 
                    
   double BuyLot=0,SelLot=0;
   
   if(Agressor && (Metod==Normal || Metod==Shaman))
      {   
      if(BuyPriceMinLot==0) BuyLot=StartLots; else BuyLot=MathCeil(BuyPriceMinLot * 100 * CoeffLots)/100;
      if(SelPriceMaxLot==0) SelLot=StartLots; else SelLot=MathCeil(SelPriceMaxLot * 100 * CoeffLots)/100;
      }
   if(!Agressor && (Metod==Normal || Metod==Shaman))
      {   
      if(BuyPriceMinLot==0) SelLot=StartLots; else SelLot=MathCeil(BuyPriceMinLot * 100 * CoeffLots)/100;
      if(SelPriceMaxLot==0) BuyLot=StartLots; else BuyLot=MathCeil(SelPriceMaxLot * 100 * CoeffLots)/100;
      }
   if(Metod==ShamanSmart)
      {   
      if(SelPriceMaxLot==0) BuyLot=StartLots; else BuyLot=SelLotsSum*2;
      if(BuyPriceMinLot==0) SelLot=StartLots; else SelLot=BuyLotsSum*2;
      }
   BuyLot=NormalizeDouble(BuyLot,2);
   SelLot=NormalizeDouble(SelLot,2);
//-------------------------------------------------------------//
   if(BuyLot>MaximalLots)      BuyLot=MaximalLots;
   if(SelLot>MaximalLots)      SelLot=MaximalLots;
   if(!ValidLot(BuyLot) || !ValidLot(SelLot))
      return;   
//*************************************************************//
   if(Metod==Normal)
     {
      if(Signal()==OP_BUY)
         if((b==0) || (b>0 && Ask<=BuyPriceMin-PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_BUY,BuyLot,NormalizeDouble(Ask,Digits()),Slippage,0,0," ",MagicNumber,0,clrBlue)<0)
               Print("OrderSend error #",GetLastError());
   
      if(Signal()==OP_SELL)
         if((s==0) || (s>0 && Bid>=SelPriceMax+PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_SELL,SelLot,NormalizeDouble(Bid,Digits()),Slippage,0,0," ",MagicNumber,0,clrRed)<0)
               Print("OrderSend error #",GetLastError());
     }
   //---   

Что-то мои потуги по феншую не привели к нужному результату. Видимо функции типа AccountEquity() в тестере не работают. Может кто-нибудь глянет?

<code>
//---     
if (PercentFreeEquity>0)                                 // Трал эквити разрешен.
   {                
   Equity   = AccountEquity();                           // Текущий эквити.
   if (StopEquity==0)                                    // Начало отсчета.
      StopEquity = Equity;                               // Запоминаем стартовый эквити.
                     
   double lev_eq = Equity - Equity/100*PercentFreeEquity;// Текущий уровень трала эквити.
                  
   if (StopEquity < lev_eq)                              // Если уровень стоп-эквити подрос, 
      StopEquity  = lev_eq;                              // подтягиваем стоп-эквити до
                                                         // уровня срабатывания.
   if (StopEquity >= lev_eq && GetProfit()>0)
      {
      CloseAll();
      StopEquity = 0;
      }
   }
   //---
</code>

Т.е. лажа. Пока другие доработки.

Изменил условия открытия сделок. Добавил свой индикатор. Можете поэкспериментировать со своими. Добавил новую функцию высокочастотной торговли. Можно хорошо зарабатывать на возврате спреда и (или) комиссии.

Уважаемый Jimirami, не совсем понятна ваша идея. Дело не в засоре ветки. Наоборот. Всегда рад. Тут идея советника в другом: мы открываем сделки в сторону БУ. Таким образом подтягиваем общий БУ к текущей цене. Это главная идея. Если Магомед не может… Я бы больше озаботился вопросом, каким образом и по какой причине мы открываем новые сделки. Вы правы в одном. Когда-то же надо фиксировать. прибыль. Блин, времени катастрофически… Попробую на днях написать трал эквити. Может посмотрите в своих загашниках. У меня готового нет. Прикручу ваш. Идея трала: Задаем убыток в деньгах, при котором выключаем свет. Потом эту линию при росте эквити, подтягиваем к линии возрастающего эквити. Наступит такой момент, когда советник закроется при откате эквити к линии СТОР. Возможно понадобится защита от большого количества ордеров. Чтоб не съели свободную маржу. Маржинкол никому не нужен.

Что тралить то? Разве что прибыль.

Вторая часть Shaman V 1.4. Склейте.

   if(Metod==Shaman || Metod==ShamanSmart)
     {
      if(Signal()==OP_BUY && Ask<FullBU)
         if((b==0) || (b>0 && Ask<=BuyPriceMin-PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_BUY,NormalizeDouble(BuyLot,2),NormalizeDouble(Ask,Digits()),Slippage,0,0," ",MagicNumber,0,clrBlue)<0)
               Print("OrderSend error #",GetLastError());
   
      if(Signal()==OP_SELL && Bid>FullBU)
         if((s==0) || (s>0 && Bid>=SelPriceMax+PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_SELL,NormalizeDouble(SelLot,2),NormalizeDouble(Bid,Digits()),Slippage,0,0," ",MagicNumber,0,clrRed)<0)
               Print("OrderSend error #",GetLastError());
     }
//****************  Усреднение ордеров **********************************//
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
               {
               op=NormalizeDouble(OrderOpenPrice(),Digits());
               tp=NormalizeDouble(OrderTakeProfit(),Digits());
               lt=NormalizeDouble(OrderLots(),2);
               tk=OrderTicket();

               if(OrderType()==OP_BUY)
                  { 
                  if(b>=1 && tp==0) // Если есть ордера на покупку и их ТР=0, то выставляем ему ТР.
                                    // Откуда ТР=0? Это новый открытый, а также с обнуленным ТР. Читай дальше, когда обнуляем.
                     if(!OrderModify(tk,op,OrderStopLoss(),NormalizeDouble(Ask+TakeProfit*Point(),Digits()),0,clrNONE))
                        Print("OrderModify error #",GetLastError());
   
                  if(b>=CountAverge)// Если ордеров на покупку не менее, чем мы определили для сокращения
                     {              // то пытаемся сократить крайние из них.
                     if(tk==BuyPriceMaxTic || tk==BuyPriceMinTic)
                        if(Bid<AwerageBuyPrice && tp!=AwerageBuyPrice)
                           if(!OrderModify(tk,op,OrderStopLoss(),AwerageBuyPrice,0,clrNONE))// Dыставляем им ТР в общий БУ+.
                              Print("OrderModify error #",GetLastError());
   
                     if(tk!=BuyPriceMaxTic && tk!=BuyPriceMinTic && tp<op+(TakeProfit-5)*Point())// Если появился очередной усредняющий ордер, то 
                        if(!OrderModify(tk,op,0,NormalizeDouble(op+TakeProfit*Point(),Digits),0,clrNONE))             // предыдущему (уже не крайнему) обнуляем ТР.
                           Print("OrderModify error #",GetLastError());   // затем в строках 220-223 вернем ему "родной" ТР. 
                     }
                     
                  if(Revers && Bid<=op-slv)
                     if(OrderSend(Symbol(),OP_SELL,lt,NormalizeDouble(Bid,Digits()),Slippage,0,0," ",MagicNumber,0,clrRed)<0)
                        Print("OrderSend error #",GetLastError());
                  }
               //---                   
               if(OrderType()==OP_SELL)
                  { 
                  if(s>=1 && tp==0)
                     if(!OrderModify(tk,op,OrderStopLoss(),NormalizeDouble(Bid-TakeProfit*Point(),Digits()),0,clrNONE))
                        Print("OrderModify error #",GetLastError());
                        
                  if(s>=CountAverge)
                     {
                     if(tk==SelPriceMaxTic || tk==SelPriceMinTic)
                        if(Ask>AwerageSelPrice && tp!=AwerageSelPrice)
                           if(!OrderModify(tk,op,OrderStopLoss(),AwerageSelPrice,0,clrNONE))
                              Print("OrderModify error #",GetLastError());
   
                     if(tk!=SelPriceMaxTic && tk!=SelPriceMinTic && tp>op-(TakeProfit-5)*Point())
                        if(!OrderModify(tk,op,0,NormalizeDouble(op-TakeProfit*Point(),Digits()),0,clrNONE))
                           Print("OrderModify error #",GetLastError());

                     if(Revers>0 && Ask>=op+slv)
                        if(OrderSend(Symbol(),OP_BUY,lt,NormalizeDouble(Ask,Digits()),Slippage,0,0," ",MagicNumber,0,clrBlue)<0)
                           Print("OrderSend error #",GetLastError());
                     }
                  }
               }
}
//************************************************************************************************/
bool CheckVolumeValue(double volume)
{
//--- минимально допустимый объем для торговых операций
   double min_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
   if(volume<min_volume)
      return(false);

//--- максимально допустимый объем для торговых операций
   double max_volume=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
   if(volume>max_volume)
      return(false);

//--- получим минимальную градацию объема
   double volume_step=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_STEP);

   int ratio=(int)MathRound(volume/volume_step);
   if(MathAbs(ratio*volume_step-volume)>0.0000001)
      return(false);

   return(true);
}
//************************************************************************************************/
/*СИГНАЛ*/
//------------------------------------------------------------------	
int Signal()                   // Создаем функцию получения сигнала на указанном ТФ и баре
{
        double current_openprice = iOpen (Symbol(),TF , iB);
        double Mashka =iMA(NULL,0,Per_MA,0,0,4,iB) ;
        double Atrium=0;
        
          Atrium  = 0.2 * iATR(NULL,TF_ATR,Per_MA,iB);
         
          if(Bid>=current_openprice)                                               
            {
            SellBuff = (58000000.0 * (Bid  - Mashka) * Atrium);
            BuyBuff  = (58000000.0 * (Low[iB]   - Mashka) * Atrium);
            }
          if(Bid<current_openprice)
            {
            SellBuff = (58000000.0 * (High[iB]  - Mashka) * Atrium);
            BuyBuff  = (58000000.0 * (Bid   - Mashka) * Atrium);
            }
          if (SellBuff >  LevelSell) 
            return OP_SELL;
          
          if (BuyBuff < -LevelBuy) 
            return OP_BUY;
	return -1;                   // Иначе нет сигнала. Возвращаем в int Signai () -1 (никаких сигналов)
}
//************************************************************************************************
double GetProfit()
{  
   double Profit=0;
     
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              Profit += OrderProfit() + OrderCommission() + OrderSwap();
   return (Profit);
}
//************************************************************************************************
bool CloseAll()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
              {
              if(OrderType()==OP_BUY)
                if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              if(OrderType()==OP_SELL)
                if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              }
   return true;
}
//************************************************************************************************
bool ClosePlus()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol() && OrderProfit()>0)
              {
              if(OrderType()==OP_BUY)
                if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              if(OrderType()==OP_SELL)
                if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              }
   return true;
}
//************************************************************************************************
bool CloseMinus()
{ 
   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol() && OrderProfit()<=0)
              {
              if(OrderType()==OP_BUY)
                if(!OrderClose(OrderTicket(),OrderLots(),Bid,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              if(OrderType()==OP_SELL)
                if(!OrderClose(OrderTicket(),OrderLots(),Ask,Slippage))
                  {
                  Sleep(500);
                  i=i+1;//??????????????
                  }
              }
   return true;
}
//************************************************************************************************

Исправил постоянную модернизацию ТР ордеров. Ошибка 134 — не жадничайте. Выделяйте много депозита. Потом думать будете, что и как.

Shaman V 1.4

//+------------------------------------------------------------------+
//|                                                 Shaman_v 1.4.mq4 |
//|                                             fromme2you@yandex.ru |
//+------------------------------------------------------------------+
#property strict
//---
enum ENUM_Metod
  {
   Shaman       = 0,  
   ShamanSmart  = 1,  
   Normal       = 2     
  };
input ENUM_Metod      Metod               = Shaman;    // Metod - тип работы советника, метод открытия ордеров.
input bool            Agressor            = true;      // Agressor - функция влияет только на расчет ордеров.
input bool            Revers              = false;     // Вместо SL создает полный замок.
input int             CloseLim            = 5;         // Close Limit - функция оставляет к-во ордеров в каждом направлении.
input int             CountAverge         = 3;         // Количество усредняющих ордеров для сокращения с MinimalProfit.
//---      
input double          StartLots           = 0.05;      // Start lot
input double          CoeffLots           = 1.7;      
input double          MaximalLots         = 2.56;      // Maximal Lot 
input int             StopLoss            = 352;       // Stop Loss (in pips)
input int             TakeProfit          = 737;       // Take Profit (in pips)
input int             PointOrderStep      = 33;        // Point order step (in pips)
input int             MinimalProfit       = 35;        // Minimal profit for close Average orders (in pips)
//---
input ENUM_TIMEFRAMES TF                  = PERIOD_H1; // Тайм Фрейм для расчета входа
input ENUM_TIMEFRAMES TF_ATR              = PERIOD_H1; // Тайм Фрейм для ATR
input int             Per_MA              = 14;
input int             LevelSell           = 22;
input int             LevelBuy            = 62;
//---
input int             MagicNumber         = 1961;      // Magic Number 
input int             Slippage            = 30;        // Slippage 
//---
double SellBuff;
double BuyBuff;
double ShortSig;
double LongSig;
double op,lt,tp,slv;
int    tk,b,s;
int    iB=1;
double BuyPriceMax=0,BuyPriceMin=0,BuyPriceMaxLot=0,BuyPriceMinLot=0,
       SelPriceMin=0,SelPriceMax=0,SelPriceMinLot=0,SelPriceMaxLot=0;
double FullBU,BuyBU,SelBU;
//************************************************************************************************/
int OnInit()
{
     slv = StopLoss*Point;
     Comment("");
  return(INIT_SUCCEEDED);
}
//**********************************************************************************************/
void OnTick()
{//------------------- Сначала изучаем текущую обстановку по ордерам ---------------------------/
   BuyPriceMax=0;BuyPriceMin=0;BuyPriceMaxLot=0;BuyPriceMinLot=0;
   SelPriceMin=0;SelPriceMax=0;SelPriceMinLot=0;SelPriceMaxLot=0;

   int
   BuyPriceMaxTic=0,BuyPriceMinTic=0,SelPriceMaxTic=0,SelPriceMinTic=0;
   
   double
   BuyLotsSum=0,SelLotsSum=0,WeighBuy=0, WeighSell=0;

   op=0;lt=0;tp=0;
   FullBU=0;
   tk=0;b=0;s=0;

   for(int i=OrdersTotal()-1;i>=0;i--)
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
         if(OrderMagicNumber()==MagicNumber)
            if(OrderSymbol()==Symbol())
               {
               op=NormalizeDouble(OrderOpenPrice(),Digits());
               lt=NormalizeDouble(OrderLots(),2);
               tk=OrderTicket();
               
               if(OrderType()==OP_BUY)
                  {
                  b++;
                  BuyLotsSum += lt;
                  WeighBuy   += lt*op;
                  
                  if(op>BuyPriceMax || BuyPriceMax==0)
                     {
                     BuyPriceMax    = op;
                     BuyPriceMaxLot = lt;
                     BuyPriceMaxTic = tk;
                     }
                  if(op<BuyPriceMin || BuyPriceMin==0)
                     {
                     BuyPriceMin    = op;
                     BuyPriceMinLot = lt;
                     BuyPriceMinTic = tk;
                     }
                  }
               // ===
               if(OrderType()==OP_SELL)
                  {
                  s++;
                  SelLotsSum += lt;
                  WeighSell  += lt*op;
                  
                  if(op>SelPriceMax || SelPriceMax==0)
                     {
                     SelPriceMax    = op;
                     SelPriceMaxLot = lt;
                     SelPriceMaxTic = tk;
                     }
                  if(op<SelPriceMin || SelPriceMin==0)
                     {
                     SelPriceMin    = op;
                     SelPriceMinLot = lt;
                     SelPriceMinTic = tk;
                     }
                  }
               }
            //---
            if(b>CloseLim && CloseLim!=0)    // Если ордеров на покупку больше заданного (усредняющие ордера)
              if(OrderClose (BuyPriceMaxTic, BuyPriceMaxLot, Bid , Slippage, clrBlue)) // Закрываем дальний.
                return;                                                                // опять пересчитываем текучку.
                
            if(s>CloseLim && CloseLim!=0)
              if(OrderClose (SelPriceMinTic, SelPriceMinLot, Ask , Slippage, clrRed)) 
                return;
            //---
            if(Metod!=Normal)  
               if ((BuyLotsSum - SelLotsSum) != 0) 
                  FullBU = (WeighBuy - WeighSell)/(BuyLotsSum - SelLotsSum);// Определяем цену общего БУ для всех ордеров
//***************** Определение БУ+MinTP для крайник ордеров одного направления ***************************//
   double   AwerageBuyPrice=0,AwerageSelPrice=0;
   if(b>=CountAverge) AwerageBuyPrice=NormalizeDouble
         ((BuyPriceMax*BuyPriceMaxLot+BuyPriceMin*BuyPriceMinLot)/(BuyPriceMaxLot+BuyPriceMinLot)+MinimalProfit*Point(),Digits());
   if(s>=CountAverge) AwerageSelPrice=NormalizeDouble
         ((SelPriceMax*SelPriceMaxLot+SelPriceMin*SelPriceMinLot)/(SelPriceMaxLot+SelPriceMinLot)-MinimalProfit*Point(),Digits());
//*************************************************************//
   double BuyLot=0,SelLot=0;
   
   if(Agressor && (Metod==Normal || Metod==Shaman))
      {   
      if(BuyPriceMinLot==0) 
         BuyLot=StartLots; 
      else 
         BuyLot=MathCeil(BuyPriceMinLot * 100 * CoeffLots)/100;
         
      if(SelPriceMaxLot==0) 
         SelLot=StartLots; 
      else 
         SelLot=MathCeil(SelPriceMaxLot * 100 * CoeffLots)/100;
      }
   if(!Agressor && (Metod==Normal || Metod==Shaman))
      {   
      if(BuyPriceMinLot==0) 
         SelLot=StartLots; 
      else 
         SelLot=MathCeil(BuyPriceMinLot * 100 * CoeffLots)/100;
         
      if(SelPriceMaxLot==0) 
         BuyLot=StartLots; 
      else 
         BuyLot=MathCeil(SelPriceMaxLot * 100 * CoeffLots)/100;
      }
   if(Metod==ShamanSmart)
      {   
      if(SelPriceMaxLot==0) 
         BuyLot=StartLots; 
      else 
         BuyLot=SelLotsSum*2;
         
      if(BuyPriceMinLot==0) 
         SelLot=StartLots; 
      else 
         SelLot=BuyLotsSum*2;
      }
//*************************************************************//

   if(BuyLot>MaximalLots)      BuyLot=MaximalLots;
   if(SelLot>MaximalLots)      SelLot=MaximalLots;
   if(!CheckVolumeValue(BuyLot) || !CheckVolumeValue(SelLot))
      return;   
//*************************************************************//
   if(Metod==Normal)
      {
      if(Signal()==OP_BUY)
         if((b==0) || (b>0 && Ask<=BuyPriceMin-PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_BUY,NormalizeDouble(BuyLot,2),NormalizeDouble(Ask,Digits()),Slippage,0,0," ",MagicNumber,0,clrBlue)<0)
               Print("OrderSend error #",GetLastError());
      if(Signal()==OP_SELL)
         if((s==0) || (s>0 && Bid>=SelPriceMax+PointOrderStep*Point()))
            if(OrderSend(Symbol(),OP_SELL,NormalizeDouble(SelLot,2),NormalizeDouble(Bid,Digits()),Slippage,0,0," ",MagicNumber,0,clrRed)<0)
               Print("OrderSend error #",GetLastError());
      }

Если не сольет. Раньше срока. А вообще любой советник, даже с кучей ошибок может зарабатывать. Вопрос в одном. Как долго?

Ну опыт у каждого свой. Но делиться сам… велел. А Ваша стратегия неваляшкой называется. Кажется.

Работаешь себе по любимому сигналу. Плюс, плюс, бац минус. По следующему сигналу увеличиваете лот на (или в) К_Мартин и пытаетесь отыграть потери убыточного ордера. Нормальная так себе стратегия. Но тут осторожность нужна. А человек себе хочет спокойной торговли. Пусть хоть и не супер прибыльной.

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