Navigation:Home > Content >

Integra_NR_v2.7.20.mq4

Time: 2011-04-23 | Download file:Integra_NR_v2.7.20.mq4

//+------------------------------------------------------------------+
//|                                               Integra_NR_v2.7.20 |
//|                                                           Kordan |
//|                                            http://martinforex.tk |
//+------------------------------------------------------------------+

//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA
/*
   Советник с динамическим лотом выставления колен сопровождения серии. Т.е. колени выставляются не ранее PipStep по сигналам индикаторов.  
   Лотность колен возрастает с увеличением пройденного расстояния от PipStep до сигнала индикаторов с целью максимально приблизить
уровень ТП к текущей цене.
   Трал в валюте депозита сделан с целью приближения уровня динамического ТП серии с каждым коленом к текущей цене при больших объемах
и максимальному извлечению прибыли в начале серии при еще малых объемах ордеров.
   Добавлено перекрытие ордеров.
*/

#property copyright             "Kordan"
#property link                  "http://www.leprecontrading.com/client/register.php?ref=103264"
#include                                // Моя партнерка в компании Лепрекон - "Возврат спреда". Прекрасно работают парни. Рекомендую.                                                     
#include                                  // Kordan    Z984090990532 или R355833322963

extern string t0 =              "ТП в валюте депозита";
extern double DefaultProfit      =           10;      // Тейк профит в валюте депозита (гарантированная сумма профита)

extern string t1 =              "Установки расстояний";
extern int    Tral_Start         =            2;      // Расстояние начала трала от линии Profit в пунктах (классический ТП в пунктах)
extern int    Tral_Size          =           13;      // Величина трала после Tral_Start в пунктах
extern int    PipStep            =           30;      // Шаг открытия колен в пунктах

extern string t2 =              "Установки объемов и MМ";
extern int    Bonus              =            0;      // Средства, не учавствующие в торговле (в валюте депозита)
extern double Risk               =          3.5;      // Первая сделка размером в % от свободных средств, если Risk=0 то первая сделка открывается размером DefaultLot
extern double DefaultLot         =         0.01;      // Начальный лот, работает если Risk=0
extern double LotExponent        =            2;      // Коэффициент увеличения лота
extern int    LockPercent        =           40;      // Процент локового ордера от суммарного объема основной серии (пока только инфо)

extern string t3 =              "Переход на фикслот";
extern int    FixLotPercent      =           30;      // Процент просадки для автоперехода на фиксированный лот
extern bool   FixLot             =        FALSE;      // Если TRUE, то фиксированный лот, если FALSE - динамический

extern string t4 =              "Установки перекрытия";
extern int    LeadingOrder       =            4;      // C какого колена работает перекрытие
extern int    ProfitPersent      =           30;      // Процент перекрытия(10...50)
extern int    SecondProfitPersent=           50;      // Процент перекрытия когда подключается предпоследний ордер

extern string t5 =              "Ограничения"  ;
extern int    MaxTrades          =            5;      // Максимальное количество одновременно открытых колен
extern double MaxLot             =            1;      // Ограничение на максимальный лот, если MaxLot=0, то макс возможный лот ДЦ
extern int    CurrencySL         =            0;      // Ограничение по просадке в валюте депозита. Если  CurrencySL=0, то отключено.

extern string t6 =              "Закрыть Всё"  ;
extern bool   Close_All          =        FALSE;      // При вкл - принудительно закрываются все позиции, новый цикл не начинается

extern string t7 =              "Разрешить торговлю";
extern bool   ManualTrade        =        FALSE;      // При ManualTrade = TRUE первый ордер серии открывается вручную, далее серия сопровождается советником автоматически
extern bool   NewCycle_ON        =         TRUE;      // При запрете - цикл дорабатывается до конца, новый цикл не начинается
extern bool   TradeBuy           =         TRUE;      // FALSE\TRUE - Запретить\Разрешить длинные позиции  
extern bool   TradeSell          =         TRUE;      // FALSE\TRUE - Запретить\Разрешить короткие позиции 

extern string t8 =              "Установки CCI";
extern int    CCI_TimeFrame      =            2;      // ТФ      CCI  (0-текущий ТФ графика, 1=М1,2=М5,3=М15,4=М30,5=Н1,6=Н4,7=D1,8=W1,9=MN1)   
extern int    Level              =          100;      // Уровень CCI     
extern int    Period_CCI         =           14;      // Период  CCI 
extern double Sens               =            0;      // Порог шумоподавления в пунктах. Если Sens=0, то вкл штатный CCI.
       int    PriceTip           =            5;      // Тип цены
                                                      // 0 - PRICE_CLOSE    - цена закрытия 
                                                      // 1 - PRICE_OPEN     - цена открытия
                                                      // 2 - PRICE_HIGH     - макс.цена
                                                      // 3 - PRICE_LOW      - мин.цена
                                                      // 4 - PRICE_MEDIAN   - средняя цена,(high+low)/2
                                                      // 5 - PRICE_TYPICAL  - типичная цена,(high+low+close)/3
                                                      // 6 - PRICE_WEIGHTED - взвешенная цена закрытия,(high+low+close+close)/4

extern string t9 =              "Фильтры уровней по МА";
extern int    TipMAFilter        =            2;      // Тип фильтра. Если 0-Выкл, если 1-фильтр shvondera, если 2-фильтр Kordana
extern int    Period_МА          =         1000;      // Период скользящей средней
extern int    Distance_МА        =          350;      // Если Тип1 - Дистанция в пунктах на сколько цена должна отойти от МА для открытия ордера. Работа в сторону МА.
                                                      // Если Тип2 - Уровень запрета открытия ордеров выше/ниже от скользящей средней в пунктах. Отсечка на краях диапазона.
extern string t10 =             "Фильтр времени";
extern bool   UseFilterTime      =        FALSE;      // Использовать запрет торговли в пятницу после и в понедельник до указанных времен
extern bool   UseFilterDate      =        FALSE;      // Использовать запрет торговли в конце и начале месяца
extern int    StartHourMonday    =            7;      // Время начала торговли в понедельник
extern int    EndHourFriday      =           19;      // Время конца  торговли в пятницу
extern int    StartMonth         =            1;      // Начать торги после N дней начала  месяца
extern int    EndMonth           =            1;      // Закончит торговлю за N дней до конца месяца включительно

extern string t11 =             "Изменение цвета и размера индикации";
extern color  ColorInd           =       Silver;      // Цвет основной индикации
extern color  ColorTP            =       Silver;      // Цвет линии Profit
extern color  ColTPTrail         =   DarkOrange;      // Цвет линии Profit после срабатывания трала
extern color  ColorZL            =  DeepSkyBlue;      // Цвет линии безубытка
extern int    xDist1             =          300;      // Расстояние по горизонтали блока трала и нехватки средств
extern int    xDist2             =          800;      // Расстояние по горизонтали блока суммарных профитов и объемов
extern int    FontSize           =            9;      // Размер шрифта индикации

extern string t12 =             "Дополнительные параметры";
extern bool   Info               =         TRUE;      // Вкл индикации, звукового сопровождения открытия колен и подробного протоколирования
extern bool   VisualMode         =        FALSE;      // Вкл режима ручного управления
extern int    MagicNumber        =          777;      // Уникальный номер советника (при MagicNumber=0 сов подхватывает ручные ордера)
extern string MagicNumList       =  "111 0 888";      // Список, через пробел, магиков которые советник будет считать своими (не более 10)
extern int    PauseTrade         =            6;      // Время ожидания между торговыми командами в сек 

//********************************************************************************************

#import "mt4gui.dll"
   string   tbVersion()                                     ;
   string   tbGetText(int,int)                              ;   
   bool     tbIsClicked(int,int)                            ;                       
   bool     tbIsChecked(int,int)                            ;     
   int      tbPutObject(int,string,int,int,int,int,string)  ; 
   int      tbSetBgColor(int,int,int)                       ;                      
   int      tbSetTextColor(int,int,int)                     ;                   
   int      tbRemove(int,int)                               ;                              
   int      tbRemoveAll(int)                                ;                                                 
   int      tbSetText(int,int,string,int,string)            ;                                
   int      tbSetChecked(int,int,bool)                      ;                     
   int      tbEnable(int,int,int)                           ;                        
   int      tbAddListItem(int,int,string)                   ;                 
   int      tbGetListSel(int,int)                           ;                         
   int      tbSetListSel(int,int,int)                       ;              
#import

//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA 

   int      mper[10]={0,1,5,15,30,60,240,1440,10080,43200},magic[10];
   int      dig,Error,Lpos,Lpos1,Cpos,PrcCL1,cmagic,totalord,totalbuy,totalsell,spr,freez,stlev,
            buybtn,sellbtn,closebtn,lottxt,lotbtnp,lotbtnm,closesellbtn,closebuybtn,hwnd,btn1,sum;
   color    col,ZLcolor,TPcolor;
   double   TPPrice,ZeroLine,Cprofit,Lprofit,Lprofit1,PrcCL,CurrentDrawdown,CurrentUrov,Profit,SumProfit,SumLotBuy,SumLotSell,
            Lot,LotR,Sum_lot,Sumlot,minLot,maxLot,delta,delta2,TV,DrawDownRate,FreeMargin,Balance,Sredstva,One_Lot,Step,
            ProfitBuy,ProfitSell,LastLotBuy,LastLotSell,LastPriceBuy,LastPriceSell;
   string   comment,prevar;
   bool     CloseTrigger,NoTrade,CloseAll,CloseFM,fixlot,InitFail,tralinfo;

//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA  
   
int init(){  

   DeleteObject()                                     ;  // Сброс триггера и очистка экрана
   if(Bars                <  Period_МА              ) {Print("!Недостачно баров в истории!"                 ); InitFail = True;}
   if(!IsDllsAllowed()   || !IsLibrariesAllowed()   ) {Print("!Разрешите импорт DLL!Поставьте галочку!"     ); InitFail = True;}
   if(AccountFreeMargin() <  Bonus                  ) {Print("!Бонус не может превышать свободные средства!"); InitFail = True;}
   if(AccountBalance   () <  Bonus                  ) {Print("!Бонус не может превышать текущий баланс!"    ); InitFail = True;}
   if(InitFail                                      ) {Print("!Ошибка иницилизации советника!"              ); return(0)      ;}
   TV      = MarketInfo(Symbol(),MODE_TICKVALUE     ) ;   
   minLot  = MarketInfo(Symbol(),MODE_MINLOT        ) ; 
   maxLot  = MarketInfo(Symbol(),MODE_MAXLOT        ) ;
   One_Lot = MarketInfo(Symbol(),MODE_MARGINREQUIRED) ;  // Размер свободных средств, необходимых для открытия 1 лота на покупку
      Step = MarketInfo(Symbol(),MODE_LOTSTEP       ) ;  // Шаг изменения размера лота
   if(Step>= 1   ) dig=0;
   if(Step>= 0.1 ) dig=1;
   if(Step>= 0.01) dig=2;
     
//*********************************************************************************************  
   
if (VisualMode){
   hwnd=WindowHandle(Symbol(),Period());
   tbRemoveAll(hwnd);
   lottxt      = tbPutObject(hwnd,"text"  , 77,-39,70,20, DoubleToStr(LotR,2));
   buybtn      = tbPutObject(hwnd,"button",149,-39,70,20,"Buy"               );
   sellbtn     = tbPutObject(hwnd,"button",  5,-39,70,20,"Sell"              );
   closebtn    = tbPutObject(hwnd,"button",221,-39,90,20,"Закрыть все"       );
   closesellbtn= tbPutObject(hwnd,"button",313,-39,90,20,"Закрыть Sell"      );
   closebuybtn = tbPutObject(hwnd,"button",405,-39,90,20,"Закрыть Buy"       );
   tbSetBgColor(hwnd,closebtn,Gold);
}   
  
//***************** Автоматический переход на пятизнак **************************************** 

   int _digits = MarketInfo(Symbol(), MODE_DIGITS);
      if (_digits == 5 || _digits == 3){
         Tral_Start        *= 10;
         Tral_Size         *= 10;
         PipStep           *= 10;
         Distance_МА       *= 10;
         Sens              *= 10;
      }
         
//***************  Защита от неправильного выставления параметров  ****************************

   if(CCI_TimeFrame< 2  || CCI_TimeFrame>4) CCI_TimeFrame = 2;
   if(DefaultProfit<=0  )  DefaultProfit = 0.01  ;
   if(LockPercent  <=0  )  LockPercent=1         ;
   if(DefaultLot   <=0  )  DefaultLot=0.01       ;
   if(LeadingOrder <=2  )  LeadingOrder=2        ;  
   if(Bid==0.0||Ask==0.0) {Print(StringConcatenate("Неправильные цены. Ask: ",Ask," Bid: ",Bid)); return(0);}
   
//********************************************************************************************* 

cmagic=0; string st; int k=StringLen(MagicNumList);
for (int a=0; a= 2) CheckOverlapping()                    ;
   if (Sum_lot >0) sum= 1                                      ;  // Суммарный лот серии Buy больше, чем Sell
   if (Sum_lot <0) sum=-1                                      ;  // Суммарный лот серии Sell больше, чем Buy
   if (Sum_lot==0) sum= 0                                      ;  // Суммарный лот серии Sell равен Buy
   
//***************  Защита от неправильного выставления стопуровней  ***************************

int levels        =spr+freez+stlev          ;
   if(PipStep    <=levels) PipStep   =levels;
   if(Tral_Start <=levels) Tral_Start=levels; 

//===============================================================================================================================

if(time() && VisualMode){
   if(tbGetText(hwnd,lottxt)!="")LotR=StrToDouble(tbGetText(hwnd,lottxt)      );
   if (tbIsClicked(hwnd,buybtn)){
      comment=StringConcatenate("Integra - Pучник, ","Magic : ",MagicNumber   );
         SendOrder(OP_BUY ,LotR,0,0,0,comment,MagicNumber)                     ;
   }

   if (tbIsClicked(hwnd,sellbtn)){
      comment=StringConcatenate("Integra - Pучник, ","Magic : ",MagicNumber   );
         SendOrder(OP_SELL,LotR,0,0,0,comment,MagicNumber)                     ;
   }

   if (tbIsClicked(hwnd,closebtn    )) CloseThisSymbolAll(MagicNumber         );
   if (tbIsClicked(hwnd,closesellbtn)) CloseThisSymbolAll(MagicNumber, OP_SELL);
   if (tbIsClicked(hwnd,closebuybtn )) CloseThisSymbolAll(MagicNumber, OP_BUY );   
}
 
//===========================================  Управление закрытием ордеров  ==========================================

if (SumProfit<0 && CurrencySL!=0){
   if (MathAbs(SumProfit)>=CurrencySL){
      if (Info) Print("Просадка превысила заданный уровень");
         CloseFM=true;
   }
} 
     
if (totalord==0)  {CloseAll=false; Close_All=false;}
   if (Close_All || CloseAll || CloseFM){
      CloseOrders() ; Indication ("ICloseAll",2,10,150,"Закрытие ордеров",FontSize,"Times New Roman",ColorInd);
      DeleteObject(); // Сброс триггера и очистка экрана
      CloseFM=false;
         if (Info && Close_All)   Print("Закрыть ВСЁ");
   return(0);
   }

//===============================   Переход на фиксированный лот   ====================================================

if (CurrentDrawdown<=FixLotPercent) fixlot=false; else fixlot=true ;
if (FixLot)  fixlot=true ; 

//=========================================  Расчет динамического профита  ============================================
   
if(Risk!=0) Profit = NormalizeDouble(Lot*DefaultProfit/minLot,2); else Profit = DefaultProfit;  

//==========================================  Трейлинг профита  =======================================================
   
if (SumProfit>(Profit+Tral_Start*TV*Sumlot) && !CloseTrigger){
   CloseTrigger=1; TPcolor=ColTPTrail; ZLcolor=ColorZL ;
}          
   if (!CloseTrigger && totalord>0){
   TPcolor=ColorTP; ZLcolor=ColorZL      ;
   delta  = (Profit-SumProfit)/TV/Sumlot ; // Число пунктов до профита
   delta2 =  SumProfit/TV/Sumlot         ; // Число пунктов до безубытка 
      switch(sum){
         case  1 : {TPPrice=NormalizeDouble(Bid+(delta+Tral_Start)*Point,Digits); ZeroLine=NormalizeDouble(Bid-delta2*Point,Digits);} break;
         case -1 : {TPPrice=NormalizeDouble(Ask-(delta+Tral_Start)*Point,Digits); ZeroLine=NormalizeDouble(Ask+delta2*Point,Digits);} break;
      }           
   }       
   
   if (!totalord==0){
      if (!IsTesting() || IsVisualMode() || !IsOptimization()){
         DrawLine("ILineTP",TPPrice,TPcolor,2); DrawLine("ILineZL",ZeroLine,ZLcolor,0); 
         DrawText("ItxtTP","Уровень ТП",TPPrice,TPcolor); DrawText("ItxtБУ","Уровень БУ",ZeroLine,ZLcolor     );
      }
         else {ObjectDelete("ILineTP"); ObjectDelete("ILineZL"); ObjectDelete("ItxtTP"); ObjectDelete("ItxtБУ");}
   }
      
//==========================  Триггер трала  ======================================
if (Sum_lot!=0 && CloseTrigger==1){       
   switch(sum){
//==========================  Buy  ======================================      
      case  1 : if (Bid<=NormalizeDouble(TPPrice,Digits)) {if (Info) Print("Команда трала на закрытие Buy SL" );  CloseAll=true ;}
         else   if (TPPrice<(Bid-Tral_Size*Point)) TPPrice=NormalizeDouble(Bid-Tral_Size*Point,Digits );  break;
//==========================  Sell  ======================================             
      case -1 : if (Ask>=NormalizeDouble(TPPrice,Digits)) {if (Info) Print("Команда трала на закрытие Sell SL");  CloseAll=true ;}
         else   if (TPPrice>(Ask+Tral_Size*Point)) TPPrice=NormalizeDouble(Ask+Tral_Size*Point,Digits );  break; 
   } 
}
  
//********************************************************************************************* 
if (!IsTesting() || IsVisualMode() || !IsOptimization()){
   if (Info){
      MainIndication(); 
      if (Sens==0) PriceCCI(Level);   
   } 
}

//============================================================  Начало серии  ===================================================
if (!ManualTrade && NewCycle_ON && time() && !Close_All && !NoTrade){
//=========================================================  Открытие первого Buy  ==============================================

double StartLot                                      ; 
int ticketbuy=0, ticketsell=0                        ;  
   if (TradeBuy && totalbuy==0){
      if (ticketbuy ==0){
         if (GetMASignalS()==1 || !TipMAFilter==1){
            if (!GetMASignalK()==1 || !TipMAFilter==2){
               if (Signal_CCI()==1){
                  DeleteObject()                     ;
                  StartLot = NormalizeDouble(Lot,dig);     
                  if(Info) Print("Команда на открытие первого BUY");
                     comment=StringConcatenate("1-й ордер Buy, ","Magic : ",MagicNumber)           ;
                        ticketbuy = SendOrder(OP_BUY , StartLot, 0, 0, MagicNumber, comment, Error);
                  if (!IsTesting() || IsVisualMode() || !IsOptimization()){
                     if (Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.; 
                  }
               }
            }
         }
      } 
   }   
   
//=========================================================  Открытие первого Sell  =============================================

   if (TradeSell && totalsell==0){
      if (ticketsell==0){
         if (GetMASignalS()==-1 || !TipMAFilter==1){
            if (!GetMASignalK()==-1 || !TipMAFilter==2){
               if (Signal_CCI()==-1){
                  DeleteObject()                     ;
                  StartLot = NormalizeDouble(Lot,dig);    
                  if(Info) Print("Команда на открытие первого SELL");
                     comment=StringConcatenate("1-й ордер Sell, ","Magic : ",MagicNumber)            ;
                        ticketsell  = SendOrder(OP_SELL, StartLot, 0, 0, MagicNumber, comment, Error);
                  if (!IsTesting() || IsVisualMode() || !IsOptimization()){
                     if (Info) PlaySound("alert.wav");
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.; 
                  }
               }
            } 
         }   
      }        
   }   
}        

//=====================================================  Сопровождение серии  ===================================================

if (time() && !Close_All && !NoTrade){  
double NewLot,afmc;
ObjectDelete("InewLot");

      //==========================  Buy  ======================================

   if (TradeBuy && totalbuy>0 && totalbuy<=MaxTrades){
      if (Ask<(LastPriceBuy-PipStep*Point)){  
         NewLot = NewLot(1)                                          ;
            afmc = AccountFreeMarginCheck(Symbol(), OP_BUY, NewLot)  ;
if(Info) Indication ("InewLot",3,10,115,StringConcatenate("Ожидаем ордер: Buy ",DoubleToStr(NewLot,dig)," / ","Оcтанется : $",DoubleToStr(afmc,0)),FontSize,"Times New Roman",ColorInd);            
           
      if(afmc<=0) return; else
         if (GetMASignalS()==1 || !TipMAFilter==1){
            if (!GetMASignalK()==1 || !TipMAFilter==2){
               if (Signal_CCI()==1){
                  if (Info)  Print("Команда индикаторов на открытие колена - BUY")                 ;   
                     comment=StringConcatenate(totalbuy+1,"-й ордер Buy, " ,"Magic : ",MagicNumber);
                        ticketbuy = SendOrder(OP_BUY, NewLot, 0, 0, MagicNumber, comment, Error)   ;
                  if (!IsTesting() || IsVisualMode() || !IsOptimization()){
                     if (Info) PlaySound("alert.wav")                                              ;
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.;      
                  }     
               }         
            }
         }     
      }         
   }   
      
      //==========================  Sell  =====================================

   if (TradeSell && totalsell>0 && totalsell<=MaxTrades){
      if (Bid>(LastPriceSell+PipStep*Point)){ 
         NewLot = NewLot(2)                                          ;
            afmc = AccountFreeMarginCheck(Symbol(), OP_SELL, NewLot) ;
if(Info) Indication ("InewLot",3,10,115,StringConcatenate("Ожидаем ордер: Sell ",DoubleToStr(NewLot,dig)," / ","Оcтанется : $",DoubleToStr(afmc,0)),FontSize,"Times New Roman",ColorInd);            
  
      if(afmc<=0) return; else
         if (GetMASignalS()==-1 || !TipMAFilter==1){
            if (!GetMASignalK()==-1 || !TipMAFilter==2){
               if (Signal_CCI()==-1){
                  if (Info)  Print("Команда индикаторов на открытие колена - SELL")                   ; 
                     comment=StringConcatenate(totalsell+1,"-й ордер Sell, ","Magic : ",MagicNumber)  ;
                        ticketsell = SendOrder(OP_SELL, NewLot, 0, 0, MagicNumber, comment, Error)    ; 
                  if (!IsTesting() || IsVisualMode() || !IsOptimization()){
                     if (Info) PlaySound("alert.wav")                                                 ;
                        Sleep(1000); // если это не тестирование - "засыпаем" на 1 секунду.;       
                  }
               }
            }  
         } 
      }        
   }            
}    
                    
//================================================= 
   
      return(0);  // Выход из start
}

//INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA=INTEGRA

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++           ФУНКЦИИ            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//=========================================================================================================================================//
// Qimer . Функция контроля наличия своего магика                                                                                          //
//=========================================================================================================================================//

bool MagicCheck(){
   for(int i=0; i Distance_МА && Bid > iMA_Signal) Signal = -1; //Sell
   if(Ma_Bid_Diff > Distance_МА && Bid < iMA_Signal) Signal =  1; //Buy   
double LevelNoBuy =iMA_Signal-Distance_МА*Point;
double LevelNoSell=iMA_Signal+Distance_МА*Point; 
      if (!IsTesting() || IsVisualMode() || !IsOptimization()){
         DrawLine("ILevelNoBuy  ", LevelNoBuy  , RoyalBlue, 3); 
         DrawLine("ILevelNoSell ", LevelNoSell , Crimson  , 3);  
         DrawText("ItxtLevelBuy ","Filter shvonder - запрет Buy" , LevelNoBuy , RoyalBlue);
         DrawText("ItxtLevelSell","Filter shvonder - запрет Sell", LevelNoSell, Crimson  );
      }
   }
return(Signal);
}

//=========================================================================================================================================//
// Kordan . Фильтр уровней по МА K                                                                                                         //
//=========================================================================================================================================//  

int    GetMASignalK(){
   if (TipMAFilter==2){
int    Signal = 0;
double iMA_Signal  = iMA(Symbol(), PERIOD_H1, Period_МА, 0, MODE_SMMA, PRICE_CLOSE, 1);
int    Ma_Bid_Diff = MathAbs(iMA_Signal - Bid)/Point;
double LevelNoBuy =iMA_Signal+Distance_МА*Point;
double LevelNoSell=iMA_Signal-Distance_МА*Point;
      if(Ma_Bid_Diff > Distance_МА){ 
         if(Bid > iMA_Signal) Signal = 1; //Запрет Buy
         if(Bid < iMA_Signal) Signal =-1; //Запрет Sell  
      }   
      if (!IsTesting() || IsVisualMode() || !IsOptimization()){
         DrawLine("ILevelNoBuy  ", LevelNoBuy  , RoyalBlue, 3); 
         DrawLine("ILevelNoSell ", LevelNoSell , Crimson  , 3);
         DrawText("ItxtLevelBuy ","Filter Kordan - запрет Buy" , LevelNoBuy , RoyalBlue);  
         DrawText("ItxtLevelSell","Filter Kordan - запрет Sell", LevelNoSell, Crimson  ); 
      }  
   } 
return(Signal);                      
}

//=========================================================================================================================================//
// Kordan . Сигнал СCI                                                                                                                     //
//=========================================================================================================================================// 

int Signal_CCI(){
int Signal = 0                                              ;
double x0,x1,x2,x3,x4                                       ;
   x0 = iClose(Symbol(),mper[CCI_TimeFrame+1], 0)           ;
   x1 = iClose(Symbol(),mper[CCI_TimeFrame+1], 2)           ;
      if (Sens==0){
         x2 = iCCI(NULL,mper[CCI_TimeFrame],Period_CCI,0,0) ; 
         x3 = iCCI(NULL,mper[CCI_TimeFrame],Period_CCI,0,1) ;
         x4 = iCCI(NULL,mper[CCI_TimeFrame],Period_CCI,0,3) ;
      }
      else{
         x2 = iCustom(NULL,mper[CCI_TimeFrame],"iCCI.NR", Period_CCI,PriceTip,Sens, 0,0);
         x3 = iCustom(NULL,mper[CCI_TimeFrame],"iCCI.NR", Period_CCI,PriceTip,Sens, 0,1);
         x4 = iCustom(NULL,mper[CCI_TimeFrame],"iCCI.NR", Period_CCI,PriceTip,Sens, 0,3); 
      }
   if (x2>-Level && x3<-Level && x2>x4 && x1>x0) Signal = 1;    //Buy 
   if (x2< Level && x3> Level && x20) CurrentUrov = NormalizeDouble(AccountEquity()/AccountMargin()*100,0);                      
         }
      }
   }    
}

//=========================================================================================================================================//
// Kordan . Функция получения ордера с макс и мин значением прибыли                                                                        //
//=========================================================================================================================================// 

void GetOrdMaxNinProfit(){
int    Pos   =0;
double result=0,profit=0;
   for (int cnt=0;cnt0 && profit>Lprofit){
                  Lprofit1 = Lprofit         ;
                  Lpos1    = Lpos            ; 
                  Lprofit  = profit          ; //макс значение
                  Lpos     = Pos             ;
               }   
               if(profit<0 && profit MaxLot) newlot = NormalizeDouble(MaxLot,dig)                     ;   
   if (newlot < minLot) newlot = minLot                                          ;            
return(newlot)                                                                   ;
} 

//=========================================================================================================================================//
// Kordan . Функция расчета начального лота                                                                                                //
//=========================================================================================================================================//

double GetLot(){  
double lot=0                                                   ;
      if(Risk!=0)                                                    // Если кол-во лотов заданно в % от свободных средств,                                                          
         lot  =MathAbs(FreeMargin*Risk/3200/One_Lot/Step)*Step ; else// то считаем стоимость лота
         lot  =MathMax(DefaultLot,minLot)                      ;     // иначе выставляется заданное значение DefaultLot не меньше мин. размерa лота
      if(lotFreeMargin){                                   // Если лот дороже свободных средств,
         if (!IsTesting() || IsVisualMode() || !IsOptimization()){   // то выводим сообщение в режиме Тест,
            Indication ("INoMoney",2,xDist1,40,"Недостаточно средств!!!",FontSize+5,"Courier",Red) ;  // Нулевая маржа              
         }
            else{ 
               Indication ("INoMoney",2,xDist1,40,"Недостаточно средств!!! Торговля остановлена!!!",FontSize+5,"Courier",Red); 
                  NoTrade=TRUE                                 ;     // останавливаем торговлю
            }          
         return(0)                                             ;     // и выходим из функции start()
      } 
      else  ObjectDelete("INoMoney")                           ;                                           
return(lot)                                                    ;
}
 
//=========================================================================================================================================//
// amber631 . Функция фильтра по времени                                                                                                   //
//=========================================================================================================================================// 

bool time(){
bool result=false;
   if (((Hour()=EndHourFriday && DayOfWeek()==5)) && UseFilterTime)   result=false;
      else result=true;   
   if ((Day()31-EndMonth || ((Day()>28-EndMonth)&& Month()==2) || (Day()>30-EndMonth &&
      ((Month()==4) || (Month()==6) || (Month()==9) || (Month()==11))))&& UseFilterDate)                             result=false;
      else result=true; 
return(result);   
}

//=========================================================================================================================================//
// ir0407 . Функция открытия ордеров                                                                                                       //
//=========================================================================================================================================//   

int SendOrder (int Type, double Lots, int TP, int SL, int magic, string Cmnt, int Error){
double Price, Take, Stop;
int Ticket, Slippage, Color, Err; 
bool Delay = False;
   if (Info) Print("Функция открытия ордеров");
while(!IsStopped()){  
   if (!IsTesting()){ //Если мы не в режиме тестирования
      if(!IsExpertEnabled()){
         Error = ERR_TRADE_DISABLED;
         Print ("Эксперту запрещено торговать! Кнопка \"Советники\" отжата.");
         return(-1);
      }
         if (Info) Print("Эксперту разрешено торговать");
            if(!IsConnected()){
               Error = ERR_NO_CONNECTION;
               Print("Связь отсутствует!");
            return(-1);
            }
      if (Info) Print("Связь с сервером установлена");
      if(IsTradeContextBusy()){
         Print("Торговый поток занят!");
         Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
         Sleep(PauseTrade*1000);
         Delay = True;
         continue;
      }
      if (Info) Print("Торговый поток свободен");
         if(Delay){
            if(Info) Print("Обновляем котировки");
            RefreshRates();
            Delay = False;
         }
      else if (Info) Print("Котировки актуальны");
      }
            switch(Type){
               case OP_BUY:
//               if (Info) Print("Инициализируем параметры для BUY-ордера");
                Price = NormalizeDouble( Ask, Digits);
                Take = IIFd(TP == 0, 0, NormalizeDouble( Ask + TP * Point, Digits));
                Stop = IIFd(SL == 0, 0, NormalizeDouble( Ask - SL * Point, Digits));
                Color = Blue;
                break;
             case OP_SELL:
//                 if (Info) Print("Инициализируем параметры для SELL-ордера");
                 Price = NormalizeDouble( Bid, Digits);
                 Take = IIFd(TP == 0, 0, NormalizeDouble( Bid - TP * Point, Digits));
                 Stop = IIFd(SL == 0, 0, NormalizeDouble( Bid + SL * Point, Digits));
                 Color = Red;
                 break; 
             default:
               Print("!Тип ордера не соответствует требованиям!");
               return(-1);
             }   
       string NameOP=GetNameOP(Type);      
       Slippage = 2*MarketInfo(Symbol(), MODE_SPREAD);      
       if (Info) Print(StringConcatenate("Ордер: ",NameOP," / "," Цена=",Price," / ","Lot=",Lots," / ","Slip=",Slippage," pip"," / ",Cmnt)); 
       
	if(IsTradeAllowed()){
		if (Info) Print(">>>>>Торговля разрешена, отправляем ордер >>>>>");
			Ticket = OrderSend(Symbol(), Type, Lots, Price, Slippage, Stop, Take, Cmnt, magic, 0, Color);
   
		if(Ticket < 0){
         Err = GetLastError();
      if(Err == 4   || /* SERVER_BUSY       */
         Err == 129 || /* ERR_INVALID_PRICE */
         Err == 130 || /* INVALID_STOPS     */ 
         Err == 135 || /* PRICE_CHANGED     */ 
         Err == 137 || /* BROKER_BUSY       */ 
         Err == 138 || /* REQUOTE           */ 
         Err == 146 || /* TRADE_CONTEXT_BUSY*/
         Err == 136 )  /* OFF_QUOTES        */
            {
               if (!IsTesting()){
                  Print(StringConcatenate("Ошибка(OrderSend - ",Err,"): ",ErrorDescription(Err), ")"));
                  Print(StringConcatenate("Ожидаем ",PauseTrade," cek"));
                  Sleep (PauseTrade*1000);
                  Delay = True;
               continue;
               }
            }
               else{
                  Print(StringConcatenate("Критическая ошибка(OrderSend - ",Err,"): ",ErrorDescription(Err), ")"));
                  Error = Err;
               break;
               }
		}
      break;
	}
      else{
         if(Info) Print("Эксперту запрещено торговать! Снята галка в свойствах эксперта.");
      break;
      }
}
   if(Ticket > 0)
      if(Info) Print(StringConcatenate("Ордер отправлен успешно. Тикет = ",Ticket));
   else {
      if(Info) Print(StringConcatenate("Ошибка! Ордер не отправлен. (Код ошибки = ",Error,": ",ErrorDescription(Error), ")"));
   }
   return(Ticket);
}

//=========================================================================================================================================//
// KimIV . Функция "если-то" для double                                                                                                    //
//=========================================================================================================================================//

double IIFd(bool condition, double ifTrue, double ifFalse) 
{if (condition) return(ifTrue); else return(ifFalse);}

//=========================================================================================================================================//
// ir0407 . Функция закрытия ордеров                                                                                                       //
//=========================================================================================================================================//  

void CloseOrders(){
bool Delay = False;
double  ClosePrice;
color   CloseColor;
int Err;
	if (Info) Print("Функция закрытия ордеров");
		if (!IsTesting()){ //Если мы не в режиме тестирования
			if(!IsExpertEnabled()){
				Error = ERR_TRADE_DISABLED;
				Print("Эксперту запрещено торговать!");
				return;
			}
		if (Info) Print("Эксперту разрешено торговать");
			if(!IsConnected()){
				Error = ERR_NO_CONNECTION;
				Print("Связь отсутствует!");
				return;
			}
		}
		
   if (!IsTesting()){		
      if (Info) Print("Связь с сервером установлена");
   }
   
	for(int trade = OrdersTotal() - 1; trade >= 0; trade--){
		if(OrderSelect(trade, SELECT_BY_POS, MODE_TRADES)){
			if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber || MagicCheck()){
if (Info) Print("Закрываем ордер #", OrderTicket());
				while(!IsStopped()){
					if(IsTradeContextBusy()){
						Print("Торговый поток занят!");
						Print(StringConcatenate("Ожидаем ",PauseTrade," cek")); 
						Sleep(PauseTrade*1000);
						Delay = True;
					continue;
					}
					
   if (!IsTesting()){		
      if (Info) Print("Торговый поток свободен");
   }					
						if (Delay){
							if (Info) Print("Обновляем котировки");
							RefreshRates();
							Delay = False;
						}
							switch(OrderType()){
								case OP_BUY : ClosePrice = NormalizeDouble(Bid, Digits); CloseColor = Blue; break;
								case OP_SELL: ClosePrice = NormalizeDouble(Ask, Digits); CloseColor = Red ; break;
							}
							
   int Slippage = 2*MarketInfo(Symbol(), MODE_SPREAD);
      if (Info) Print(StringConcatenate("Цена закрытия=",ClosePrice," / ","Slip = ",Slippage," pip"));  
							if(!IsTradeAllowed()){
								Print("Эксперту запрещено торговать, снята галка в свойствах эксперта!");
								return;
							}
								else
					if(!OrderClose(OrderTicket(), OrderLots(), ClosePrice, Slippage, CloseColor)){
						Err = GetLastError();
						if(Err == 4   || /* SERVER_BUSY       */
							Err == 129 || /* ERR_INVALID_PRICE */ 
							Err == 130 || /* INVALID_STOPS     */ 
							Err == 135 || /* PRICE_CHANGED     */ 
							Err == 137 || /* BROKER_BUSY       */ 
							Err == 138 || /* REQUOTE           */ 
							Err == 146 || /* TRADE_CONTEXT_BUSY*/
							Err == 136 ){ /* OFF_QUOTES        */
								Print(StringConcatenate("Ошибка(OrderClose - ",Err,"): ",ErrorDescription(Err), ")")); 
								Print(StringConcatenate("Ожидаем ",PauseTrade," cek")); 
								Sleep(PauseTrade*1000);
								Delay = True;
								continue;
							}
							else{
								Print(StringConcatenate("Критическая ошибка(OrderClose - ",Err,"): ",ErrorDescription(Err), ")"));
								break;
							}
					} 	else break;								
				}   Sleep(100);        // конец while(!IsStopped())	
			}
		}	
	}		
if (Info) Print("Конец функции закрытия ордеров.");
	return;
}

//=========================================================================================================================================//
// shvonder . Перекрытие ордеров                                                                                                           //
//=========================================================================================================================================//

void CheckOverlapping(){
Lpos = 0; Cpos = 0; Lprofit = 0; Cprofit = 0;
GetOrdMaxNinProfit();
   if (totalbuy >= LeadingOrder || totalsell >= LeadingOrder){
      if(Lprofit > 0 && Lprofit1 <= 0 && Cprofit < 0){
         if(Lprofit + Cprofit > 0 && (Lprofit + Cprofit)*100/Lprofit > ProfitPersent){
            Lpos1 = 0;
            CloseSelectOrder(); 
         }
      }  else
      
      if(Lprofit > 0 && Lprofit1 > 0 && (totalbuy > LeadingOrder || totalsell > LeadingOrder) && Cprofit < 0 ){
         if(Lprofit + Lprofit1 + Cprofit > 0 && (Lprofit + Lprofit1 + Cprofit)*100/(Lprofit + Lprofit1) > SecondProfitPersent) 
            CloseSelectOrder();          
      }
   } 
}

//=========================================================================================================================================//
// shvonder . Функция закрытия перекрытых ордеров                                                                                          //
//=========================================================================================================================================//

void CloseSelectOrder(){
if (Info) Print("Функция перекрытия ордеров.");
   int error  = 0;
   int error1 = 0;
   int error2 = 0;
   int Slippage = 2*MarketInfo(Symbol(), MODE_SPREAD);
   
//                       ---------------------- последний  -----------------------                            
       
   while (error1==0){
   RefreshRates();
   int i = OrderSelect(Lpos, SELECT_BY_TICKET, MODE_TRADES);
      if (i != 1){Print ("Ошибка! Невозможно выбрать ордер с наибольшим профитом. Выполнение перекрытия отменено."); return (0);}  
         if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber || MagicCheck()){
            switch(OrderType()){
               case OP_BUY : error1 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue); break;       
               case OP_SELL: error1 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red ); break;
            } 
               if (error1 == 1) { if (Info) Print ("Лидирующий ордер закрыт успешно"); Sleep (500); }
               else Print ("Ошибка закрытия лидирующего ордера, повторяем операцию.");                     
         }
   }

//                       ---------------------- пред последний  -----------------------   
                         
   if(Lpos1 != 0){
      while (error2==0){
         RefreshRates();
         i = OrderSelect(Lpos1, SELECT_BY_TICKET, MODE_TRADES);
            if  (i != 1 ){Print ("Ошибка! Невозможно выбрать пред ордер с наибольшим профитом. Выполнение перекрытия отменено."); return (0);}  
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber || MagicCheck()){
               switch(OrderType()){
                  case OP_BUY : error2 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue); break;       
                  case OP_SELL: error2 = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red ); break;
               } 
                  if (error2 == 1) { if (Info) Print ("Пред Лидирующий ордер закрыт успешно"); Sleep (500); } 
                  else Print ("Ошибка закрытия Пред лидирующего ордера, повторяем операцию.");                     
               }
            } 
      }
      
//                      ----------- выбранный (обычно с наименьшим профитом ) -----------

   while (error == 0){
      RefreshRates();
      i = OrderSelect(Cpos, SELECT_BY_TICKET, MODE_TRADES);
         if  (i != 1 ){Print ("Ошибка! Невозможно выбрать ордер с наименьшим профитом. Выполнение перекрытия отменено."); return (0);}    
            if (OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber || MagicCheck()){
               switch(OrderType()){
                  case OP_BUY : error = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Slippage, Blue); break;       
                  case OP_SELL: error = OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Slippage, Red ); break;
               }  
                  if (error == 1){ if (Info) Print ("Перекрываемый ордер закрыт успешно." ); Sleep (500); } 
                  else Print ("Ошибка закрытия перекрываемого ордера, повторяем операцию.");                     
            }
   }  
if (Info) Print("Конец функции перекрытия ордеров.");
	return;             
}

//=========================================================================================================================================//
// Kordan . Функция удаления объектов                                                                                                      //
//=========================================================================================================================================//

int DeleteObject() {
CloseTrigger=0; TPPrice=0; ZeroLine=0     ;
int    ObjTotal = ObjectsTotal()          ;
string ObName                             ;
   for(int i = 0; i < ObjTotal; i++){
   ObName = ObjectName(i)                 ;
      if(StringSubstr(ObName,0,1) == "I" 
      || StringSubstr(ObName,0,1) == "i") { 
         ObjectDelete(ObName)             ;
            Comment("")                   ; 
         i = i - 1                        ;
      }
   }
return(0);      
} 

//=========================================================================================================================================//
// Qimer . Отрисовка линий                                                                                                                 //
//=========================================================================================================================================//

void DrawLine(string name,double price, color col, int width){
   if (ObjectFind(name)<0)
      ObjectCreate(name,OBJ_HLINE,0,0,price); 
         else 
            ObjectMove(name,0,Time[1],price);
         ObjectSet(name,OBJPROP_COLOR,col)  ;
      ObjectSet(name,OBJPROP_WIDTH,width)   ;
}

//=========================================================================================================================================//
// Qimer . Отрисовка текста                                                                                                                //
//=========================================================================================================================================//

void DrawText(string name, string txt, double y, color col){  
   if (ObjectFind(name)<0) ObjectCreate(name,OBJ_TEXT,0,Time[WindowFirstVisibleBar()-WindowFirstVisibleBar()/5],y);
      else ObjectMove(name,0,Time[WindowFirstVisibleBar()-WindowFirstVisibleBar()/4],y);
   ObjectSetText(name,txt,10,"Times New Roman",col);
}

//=========================================================================================================================================//
// Kordan . Индикация                                                                                                                      //
//=========================================================================================================================================//   

void Indication (string name,int corner,int Xdist,int Ydist,string txt,int fontsize,string font,color col){
   if (ObjectFind(name)<0)
      ObjectCreate(name,OBJ_LABEL,0,0,0)             ; 
         ObjectSet(name, OBJPROP_CORNER, corner)     ;
            ObjectSet(name, OBJPROP_XDISTANCE, Xdist);
         ObjectSet(name, OBJPROP_YDISTANCE, Ydist)   ;
      ObjectSetText(name,txt,fontsize,font,col)      ; 
} 

//=========================================================================================================================================//
// Функция отрисовки и расчета CCI                                                                                                         //
//=========================================================================================================================================//
 
double PriceCCI(double Level, int CurrentCandle=0){
double MovBuffer;
double Price, SummPrice, Abs, SummAbs;
double K = 0.015;
int j;
   for(int i=Period_CCI-1; i>=0; i--){
      j=i+CurrentCandle;
         Price = (High[j]+Low[j]+Close[j])/3;
            MovBuffer = iMA(NULL,0,Period_CCI,0,MODE_SMA,PRICE_TYPICAL,CurrentCandle);
               Abs    = MathAbs(Price-MovBuffer);
      if(i>0){
         SummPrice += Price;
            SummAbs+= Abs;
      }
   }
   if(Info==true) {        
      double CCI = (Price-MovBuffer)/((SummAbs+Abs)*K/Period_CCI);
Indication ("ICCI",2,10,45,StringConcatenate("CCI (",DoubleToStr(Level,0),",",Period_CCI,",",CCI_TimeFrame,") = ",DoubleToStr(CCI,0)),FontSize,"Times New Roman",ColorInd);   
   }
      
double H = High[CurrentCandle];
double L =  Low[CurrentCandle];
i = Period_CCI;
   if(CCI>=0){
      CCI=Level;
         Price = -(H*i-L*i*i-H*i*i+L*i-CCI*H*K-CCI*L*K+3*SummPrice*i-
            CCI*3*K*SummPrice+CCI*H*K*i+CCI*L*K*i+CCI*3*K*SummAbs*i)/(i-i*i-CCI*K+CCI*K*i);
   }
      else{
      CCI=-Level;
         Price = -(H*i-L*i*i-H*i*i+L*i+CCI*H*K+CCI*L*K+3*SummPrice*i+
            CCI*3*K*SummPrice-CCI*H*K*i-CCI*L*K*i+CCI*3*K*SummAbs*i)/(i-i*i+CCI*K-CCI*K*i);
   }
if(ObjectFind("ILineCCI")!=-1) ObjectDelete("ILineCCI"    );
if(ObjectFind("ItxtCCI" )!=-1) ObjectDelete("ItxtCCI"     );
   if(Price>H){
      ObjectCreate("ILineCCI", OBJ_HLINE, 0, 0,Price      );
         ObjectSet   ("ILineCCI", OBJPROP_COLOR, SteelBlue);
      DrawText("ItxtCCI",StringConcatenate("CCI < ", DoubleToStr(CCI,0)),Price,SteelBlue );
   }
      else ObjectCreate("ILineCCI", OBJ_HLINE, 0, 0,Price );
   if(Price ", DoubleToStr(CCI,0)),Price, Teal     );
   }
      else ObjectCreate("ILineCCI", OBJ_HLINE, 0, 0,Price );           
return(Price);
}

//=========================================================================================================================================//
// Kordan . Функция главной индикации                                                                                                      //
//=========================================================================================================================================//

void MainIndication() {

//========================================  Oтрисовкa профита и лотов ордеров =============================================================

int ObjTotal = ObjectsTotal();
   string ObName;
      for(int i = 0; i < ObjTotal; i++){
         ObName = ObjectName(i);
         if(Str        

Recommend