Martingail_breakdowning_v1

//+------------------------------------------------------------------+
//|               Breakdowning martingail™ v 1.0.2.mq4               | 
//|                  Copyright © 2006, B@ss & Steve                  | 
//|                        albass@mail333.com                        | 
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, B@ss & Steve"
#property link      "albass@mail333.com, http://forum.alpari-idc.ru"
//----
#include <stdlib.mqh>
// åñëè false, òî ïðè çàêðûòèè òåêóùåé ñåðèè, íîâûå îðäåðà íå áóäóò îòêðûâàòüñÿ
extern bool   TradeAllowed        = true;
//øàã â ïóíêòàõ óðîâíåé
extern int    Step                = 18;
extern string _                   = "Ïàðàìåòðû MoneyManagement";
// ðàçìåð òîðãóåìîãî ëîòà, ïðè âûêëþ÷åííîì ÌÌ
extern double startLots           = 0.1;
// âêëþ÷åíèå MoneyManagement
extern bool   MoneyManagement     = true;
// ëîãàðèôìè÷åñêèé MoneyManagement
extern bool   LogariphmicMM       = true;
// ðàçìåð ëîòà â ïðîöåíòàõ îò äåïîçèòà
extern double Riskfactor          = 6;
// ðàçìåð íóæíîãî ïðîôèòà â ïðîöåíòàõ îò äåïîçèòà
extern double ProfitPercent       = 2;
// âêëþ÷åíèå îïòèìàëüíîãî çàêðûòèÿ îðäåðîâ (ïîâûøàåò äîõîäíîñòü)
extern bool   OptimalTakeProfit   = true;
extern string __                  = "Ïàðàìåòðû ðàáîòû ýêñïåðòà";
// ðåæèì ðàáîòû ýêñïåðòà (0 - ïðîáîéíûé ñ âîçìîæíîñòüþ ñòàâèòü èíâåðñíûå îðäåðà, 
// 1 - îòáîéíûé, ñ ïåðåìåùåíèåì îòëîæåííûõ ëèìèòíûõ îðäåðîâ)
extern int    mode_work           = 0;
// òðåéëèíã-ñòîï äëÿ ïëå÷à, âûøåäøåãî â ïðèáûëü (åñëè 0, òîãäà îòñóòñòâóåò)                                           
extern int    TrailingStop        = 30;
//íå òîðãîâàòü ïîñëå çàêðûòèÿ ñåðèè äî ñëåäóþùåãî äíÿ
extern bool   NoTradeBeforeNewDay = true;
// Ðåæèì èçìåíåíèÿ øàãà Step
//   0 - âñåãäà ðàâåí Step
//   1 - ïåðâûé øàã 15, âñå îñòàëüíûå 40
//   2 - ïëàâíî ìåíÿåòñÿ ñ óìåíüøåíèåì FreeMargin îò 15 äî 40
extern int    MinMaxStepMode      = 0;
//ïîêàçûâàòü ñëóæåáíóþ èíôîðìàöèþ ïî îðäåðàì â æóðíàëå òåðìèíàëà                                                
extern bool   ShowLog             = false;
//----
int    timeOut      = 5000;
int    maxLevel     = 9;     //ìàêñèìàëüíûé îòêðûòûé óðîâåíü
double LotsLevel_2  = 1;     //øàã ïðèðàùåíèÿ ëîòîâ ñ óâåëè÷åíèåì óðîâíÿ
double LotsLevel_3  = 2;
double LotsLevel_4  = 4;
double LotsLevel_5  = 6;
double LotsLevel_6  = 10;
double LotsLevel_7  = 16;
double LotsLevel_8  = 26;
double LotsLevel_9  = 42;
double LotsLevel_10 = 64;
double LotsLevel_11 = 100;
double LotsLevel_12 = 168;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+        
int init()
  {
   ObjectCreate("label_object", OBJ_LABEL, 0, 0, 0);  
   ObjectCreate("label_object1", OBJ_LABEL, 0, 0, 0);
   ObjectCreate("label_object2", OBJ_LABEL, 0, 0, 0); 
   ObjectSet("label_object", OBJPROP_XDISTANCE, 11);  
   ObjectSet("label_object", OBJPROP_YDISTANCE, 14);
   ObjectSet("label_object1", OBJPROP_XDISTANCE, 400);
   ObjectSet("label_object1", OBJPROP_YDISTANCE, 20);
   ObjectSet("label_object2", OBJPROP_XDISTANCE, 400);  
   ObjectSet("label_object2", OBJPROP_YDISTANCE, 35);
   ObjectSetText("label_object", "Breakdowning Martingail™  version 1.0.2",
                 11, "Verdana", White);
   return(0);
  }
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ ïðîâåðÿåò íàëè÷èå îðäåðà ñ äàííûì ìàãè÷åñêèì íîìåðîì    |
//+------------------------------------------------------------------+
bool isMgNum(int num) 
  {
   int t, cnt1;
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderMagicNumber() == num && OrderSymbol() == Symbol())
         {
           return(True);// âîçâðàùàåìîå çíà÷åíèå
         }
     }  
   return (False);   
  }
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ óäàëåíèÿ îðäåðà ïî ìàãè÷åñêîìó íîìåðó                   |
//+------------------------------------------------------------------+
bool deleteOrderNum(int num) 
  {       
   int t, cnt1, err;     
   bool tic;
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {
           //òîëüêî äëÿ äàííîãî èíñòðóìåíòà      
           if(OrderMagicNumber() == num && (OrderType() == OP_BUYSTOP || 
              OrderType() == OP_SELLSTOP || OrderType() == OP_SELLLIMIT || 
              OrderType() == OP_BUYLIMIT))            
             {
               int start = GetTickCount();
               tic = OrderDelete(OrderTicket());               
               if(ShowLog)
                 {
                   Print("Âðåìÿ óäàëåíèÿ ", (GetTickCount() - start) / 1000, " ñåêóíä.");
                 }
               if(tic) 
                   PlaySound("timeout.wav");
               if(!tic) 
                 {
                   err = GetLastError();
                   Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                 } 
               return(True); // âîçâðàùàåìîå çíà÷åíèå
             }
         }   
     }  
   return (False);   
  }     
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ, ïðîâåðÿþùàÿ, àêòèâèðîâàí ëè äàííûé îðäåð â îòêðûòóþ    |
//|  ïîçèöèþ                                                         |
//+------------------------------------------------------------------+
bool isOrderActive(int num)  // èìÿ ôóíêöèè è ñïèñîê ïàðàìåòðîâ
  {       
   int t, cnt1;     
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {       
           if(OrderMagicNumber() == num) 
             {     
               if(OrderType() == OP_BUY || OrderType() == OP_SELL)
                 {
                   return(True);// âîçâðàùàåìîå çíà÷åíèå
                 }
             }
         }
     }  
   return (False);   
  } 
//+------------------------------------------------------------------+
//|  Îïðåäåëåíèå ìàñèìàëüíîãî óðîâíÿ äëÿ äëèííûõ èëè êîðîòêèõ ïîçèöèé|
//+------------------------------------------------------------------+
int getTopLevel(int mode)  // èìÿ ôóíêöèè è ñïèñîê ïàðàìåòðîâ
  {       
   int t, cnt1, tLev, cLev;
   t = OrdersTotal();
   cLev = 0;
   tLev = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {
           if(OrderType() == OP_BUY || OrderType() == OP_SELL)
             { 
               //òîëüêî àêòèâèðîâàííûå ïîçèöèè
               if(mode == 1)
                 {  
                   //ïðîâåðêà óðîâíÿ äëÿ ëîíãîâ
                   if(OrderMagicNumber() == 881) 
                       cLev = 12;
                   if(OrderMagicNumber() == 871) 
                       cLev = 11;
                   if(OrderMagicNumber() == 861) 
                       cLev = 10;
                   if(OrderMagicNumber() == 851) 
                       cLev = 9;
                   if(OrderMagicNumber() == 841) 
                       cLev = 8;
                   if(OrderMagicNumber() == 831) 
                       cLev = 7;
                   if(OrderMagicNumber() == 821) 
                       cLev = 6;
                   if(OrderMagicNumber() == 811) 
                       cLev = 5;
                   if(OrderMagicNumber() == 801) 
                       cLev = 4;
                   if(OrderMagicNumber() == 791) 
                       cLev = 3;
                   if(OrderMagicNumber() == 781) 
                       cLev = 2;
                   if(OrderMagicNumber() == 771) 
                       cLev = 1;
                 } 
               else 
                 {  
                   //ïðîâåðêà óðîâíÿ äëÿ øîðòîâ
                   if(OrderMagicNumber() == 882) 
                       cLev = 12;
                   if(OrderMagicNumber() == 872) 
                       cLev = 11;
                   if(OrderMagicNumber() == 862) 
                       cLev = 10;
                   if(OrderMagicNumber() == 852) 
                       cLev = 9;
                   if(OrderMagicNumber() == 842) 
                       cLev = 8;
                   if(OrderMagicNumber() == 832) 
                       cLev = 7;                                             
                   if(OrderMagicNumber() == 822) 
                       cLev = 6;
                   if(OrderMagicNumber() == 812) 
                       cLev = 5;
                   if(OrderMagicNumber() == 802) 
                       cLev = 4;
                   if(OrderMagicNumber() == 792) 
                       cLev = 3;
                   if(OrderMagicNumber() == 782) 
                       cLev = 2;
                   if(OrderMagicNumber() == 772) 
                       cLev = 1;             
                 }
             }   
         }
       if(cLev > tLev) 
           tLev = cLev;   
     }  
   return(tLev);   
  }
//+------------------------------------------------------------------+
//|  Îïðåäåëåíèå, ñêîëüêî ëîòîâ îòêðûâàòü ïî çàäàííîìó íîìåðó óðîâíÿ |
//+------------------------------------------------------------------+
double getLotByLevel(int level) // ôóíêöèÿ äëÿ âû÷èñëåíèÿ ëîòà ïî óðîâíþ
  {       
    double lot1;
    lot1 = startLots;  // çíà÷åíèå ïî óìîë÷àíèþ 
    if(level == 1) 
        // ïåðâûå îðäåðà - òîëüêî äëÿ îòñ÷åòà óðîâíåé, ïîçèöèè ðàçìåðîì 0,1 ëîòà
        lot1 = 0.1; 
    if(level == 2) 
        lot1 = NormalizeDouble(startLots*LotsLevel_2, 1);
    if(level == 3) 
        lot1 = NormalizeDouble(startLots*LotsLevel_3, 1);
    if(level == 4) 
        lot1 = NormalizeDouble(startLots*LotsLevel_4, 1);
    if(level == 5) 
        lot1 = NormalizeDouble(startLots*LotsLevel_5, 1);
    if(level == 6) 
        lot1 = NormalizeDouble(startLots*LotsLevel_6, 1);
    if(level == 7) 
        lot1 = NormalizeDouble(startLots*LotsLevel_7, 1);
    if(level == 8) 
        lot1 = NormalizeDouble(startLots*LotsLevel_8, 1);
    if(level == 9) 
        lot1 = NormalizeDouble(startLots*LotsLevel_9, 1);         
    if(level == 10) 
        lot1 = NormalizeDouble(startLots*LotsLevel_10, 1);         
    if(level == 11) 
        lot1 = NormalizeDouble(startLots*LotsLevel_11, 1);
    if(level == 12) 
        lot1 = NormalizeDouble(startLots*LotsLevel_12, 1);
   return(lot1);   
  }
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ ïîëó÷åíèÿ öåíû îòêðûòèÿ îðäåðà ïî åãî ìàãè÷åñêîìó íîìåðó|
//+------------------------------------------------------------------+
double getOrderPriceByNum(int num) 
  {       
   int t, cnt1;     
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {       
           if(OrderMagicNumber() == num) 
             {     
               return(OrderOpenPrice());
             }
         }
     }  
   return (0);   
  }
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ ïîëó÷åíèÿ âðåìåíè îòêðûòèÿ îðäåðà ïî åãî ìàãè÷åñêîìó    |
//|  íîìåðó                                                          |
//+------------------------------------------------------------------+
datetime getOrderOpenTimeByNum (int num)
  {       
   int t, cnt1;     
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {       
           if(OrderMagicNumber() == num) 
             {     
               return(OrderOpenTime());
             }
         }
      }  
   return (0);   
  }      
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ ñ÷èòàåò îòêðûòûå ëîòû äëÿ ëîíãîâ ïî äàííîìó èíñòðóìåíòó |
//+------------------------------------------------------------------+
double getBuyLotsSum(int mode)
  {
   int t, cnt1;
   double sm;
   t = OrdersTotal();
   sm = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(mode != 1) 
         {     
           if(OrderType() == OP_BUY && OrderSymbol() == Symbol())
             {
               sm = sm + OrderLots();
             }
         } 
       else 
         { 
           // à çäåñü ïî âñåì îòêðûòûì ïîçèöèÿì ñ÷åòà
           if(OrderType() == OP_BUY)
             {
               sm = sm + OrderLots();
             }          
         }        
     }   
   return(sm);     
  }
//+------------------------------------------------------------------+
//|  Ôóíêöèÿ ñ÷èòàåò îòêðûòûå ëîòû äëÿ øîðòîâ ïî äàííîìó èíñòðóìåíòó |
//+------------------------------------------------------------------+
double getSellLotsSum(int mode)
  {
   int t, cnt1;
   double sm;
   t = OrdersTotal();
   sm = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(mode != 1) 
         {                
           if(OrderType() == OP_SELL && OrderSymbol() == Symbol())
             {
               sm = sm + OrderLots();
             }
         } 
       else 
         {
           // à çäåñü ïî âñåì îòêðûòûì ïîçèöèÿì ñ÷åòà
           if(OrderType() == OP_SELL)
             {
               sm = sm + OrderLots();
             }          
         }    
     }   
   return(sm);     
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ äëÿ ìîäèôèêàöèè îòëîæåííûõ îðäåðîâ ëîíãîâ çäåñü          |
//| îïðåäåëÿåì ìàêñèìàëüíûé ìàãè÷åñêèé íîìåð îòêðûòîãî îðäåðà äëÿ    |
//| ëîíãîâ                                                           |
//+------------------------------------------------------------------+
int getMaxLongNum()
  {
   int t, cnt1;
   int topL;    
   t = OrdersTotal();
   topL = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {     
           if(OrderType() == OP_BUY)
             {
               if(OrderMagicNumber() > topL) 
                   topL = OrderMagicNumber();
             }
         }
     }  
   return (topL);      
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò ìàêñèìàëüíûé ìàãè÷åñêèé íîìåð îòêðûòîãî       |
//| îðäåðà äëÿ øîðòîâ                                                |
//+------------------------------------------------------------------+
int getMaxShortNum()
  {
   int t, cnt1;
   int topL;    
   t = OrdersTotal();
   topL = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {     
           if(OrderType() == OP_SELL)
             {
               if(OrderMagicNumber() > topL) 
                   topL = OrderMagicNumber();
             }
         }
     }  
   return (topL);      
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ îïðåäåëÿåò ñëåäóþùèé ìàãè÷åñêèé íîìåð ïî äàííîìó         |
//+------------------------------------------------------------------+
int getNextOrderNum(int n1)
  {        
   if(n1 == 771) 
       return (781);
   if(n1 == 781) 
       return (791);
   if(n1 == 791) 
       return (801);
   if(n1 == 801) 
       return (811);
   if(n1 == 811) 
       return (821);
   if(n1 == 821) 
       return (831);
   if(n1 == 831) 
       return (841);
   if(n1 == 841) 
       return (851);        
   if(n1 == 851) 
       return (861);
   if(n1 == 861) 
       return (871);
   if(n1 == 871) 
       return (881);
   if(n1 == 772) 
       return (782);
   if(n1 == 782) 
       return (792);
   if(n1 == 792) 
       return (802);
   if(n1 == 802) 
       return (812); 
   if(n1 == 812) 
       return (822);
   if(n1 == 822) 
       return (832); 
   if(n1 == 832) 
       return (842); 
   if(n1 == 842) 
       return (852); 
   if(n1 == 852) 
       return (862); 
   if(n1 == 862) 
       return (872); 
   if(n1 == 872) 
       return (882); 
   return (0);       
  }    
//+------------------------------------------------------------------+
//| Ôóíêöèÿ âû÷èñëåíèå ìàãè÷åñêîãî íîìåðà ïî íîìåðó óðîâíÿ           |
//+------------------------------------------------------------------+
int getNum(int dir, int level)
  {
   if(dir == 1)
     {
       //äëÿ ëîíãîâ
       if(level == 1) 
           return(771);
       if(level == 2) 
           return(781);
       if(level == 3) 
           return(791);
       if(level == 4) 
           return(801);
       if(level == 5) 
           return(811);
       if(level == 6) 
           return(821);
       if(level == 7) 
           return(831);
       if(level == 8) 
           return(841);
       if(level == 9) 
           return(851);
       if(level == 10) 
           return(861);
       if(level == 11) 
           return(871);
       if(level == 12) 
           return(881);
     } 
   else 
     {
       if(level == 1) 
           return(772);
       if(level == 2) 
           return(782);
       if(level == 3) 
           return(792);
       if(level == 4) 
           return(802);
       if(level == 5) 
           return(812);
       if(level == 6) 
           return(822);
       if(level == 7) 
           return(832);
       if(level == 8) 
           return(842);
       if(level == 9) 
           return(852);        
       if(level == 10) 
           return(862);        
       if(level == 11) 
           return(872);        
       if(level == 12) 
           return(882);        
     }     
  }     
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ìîäèôèêàöèè îòëîæåííîãî îðäåðà                           |
//+------------------------------------------------------------------+
// çäåñü ïîëó÷àåì âû÷èñëåííûå öåíû îòêðûòèÿ è òýéêïðîôèòà äëÿ 
// îòëîæåííûõ îðäåðîâ è åñëè îíè îòëè÷àþòñÿ îò öåí ìîäèôèöèðóåìîãî 
// îðäåðà, èçìåíÿåì èõ.
int modOrder(int num, double oprice, double prprice)
  {
   int t, cnt1, err, start;
   bool tic;
   double p1, p2;
   t = OrdersTotal();
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol() && OrderMagicNumber() == num)
         { 
           if((OrderOpenPrice() != oprice || OrderTakeProfit() != prprice) && 
               oprice != 0) 
             {     
               if(OrderType() == OP_BUYSTOP || OrderType() == OP_SELLLIMIT)
                 {
                   p1 = oprice;
                   p2 = prprice;
                   NormalizeDouble(p2, MarketInfo(Symbol(), MODE_DIGITS));
                   NormalizeDouble(p1, MarketInfo(Symbol(), MODE_DIGITS));
                   if(NormalizeDouble(OrderOpenPrice(), Digits) != 
                      NormalizeDouble(p1, Digits) || 
                      NormalizeDouble(OrderTakeProfit(), Digits) != 
                      NormalizeDouble(p2, Digits)) 
                     {                  
                       start = GetTickCount();
                       tic = OrderModify(OrderTicket(), p1, 0, p2, 0, Green);
                       if(ShowLog)
                         {
                           Print("ìîäèô BUYSTOP ", OrderOpenPrice(), "->", p1,
                                 " t/p ", OrderTakeProfit(), "->", p2);
                           Print("Âðåìÿ ìîäèôèêàöèè ", (GetTickCount() - start) / 1000,
                                 " ñåêóíä.");  
                         }
                       if(tic) 
                           PlaySound("alert.wav");                    
                       if(!tic) 
                         {
                           err = GetLastError(); 
                           Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                         }                     
                       Sleep(timeOut);
                     }
                 }
               if(OrderType() == OP_SELLSTOP || OrderType() == OP_BUYLIMIT)
                 {
                   p1 = oprice;
                   p2 = prprice;
                   NormalizeDouble(p2, MarketInfo(Symbol(), MODE_DIGITS));
                   NormalizeDouble(p1, MarketInfo(Symbol(), MODE_DIGITS));
                   if(NormalizeDouble(OrderOpenPrice(), Digits) != 
                      NormalizeDouble(p1, Digits) || 
                      NormalizeDouble(OrderTakeProfit(), Digits) != 
                      NormalizeDouble(p2, Digits)) 
                     { 
                       start = GetTickCount();
                       tic = OrderModify(OrderTicket(), p1, 0, p2, 0, Green);
                       if(ShowLog)
                         {
                           Print("ìîäèô SELLSTOP ", OrderOpenPrice(), "->", p1, 
                                 " t/p ", OrderTakeProfit(),"->", p2);
                           Print("Âðåìÿ ìîäèôèêàöèè ", (GetTickCount() - start) / 1000,
                                 " ñåêóíä.");  
                         }
                       if(tic) 
                           PlaySound("alert.wav");                      
                       if(!tic) 
                         {
                           err = GetLastError(); 
                           Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                         }                       
                       Sleep(timeOut);
                     }                       
                 }              
             }            
         }
     }  
   return (1);      
  }    
//+------------------------------------------------------------------+
//| Ôóíêöèÿ ïîäñ÷åòà ïðîôèòà ïî ïîçèöèÿì â çàâèñèìîñòè îò ðåæèìà: ïðè|
//| mode=1 òîëüêî äëÿ òåêóùåãî èíñòðóìåíòà, ïðè ëþáîì äðóãîì äëÿ âñåõ|
//| ïîçèöèé ñ÷åòà                                                    |
//+------------------------------------------------------------------+
double getAllProfit(int mode)
  {
   int t, cnt1;
   double pf;
   t = OrdersTotal();
   pf = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(mode == 1)
         {      
           if(OrderSymbol() == Symbol() && (OrderType() == OP_BUY || 
              OrderType() == OP_SELL))
             {
               pf = pf + OrderProfit() + OrderSwap() + OrderCommission();           
             }
         } 
       else 
         {
           if(mode == 2 && OrderSymbol() == Symbol() && OrderType() == OP_BUY) 
             {
               pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
             }
           if(mode == 3 && OrderSymbol() == Symbol() && OrderType() == OP_SELL)
             {
               pf = pf + OrderProfit() + OrderSwap() + OrderCommission();                        
             }   
         }
     }  
   return (pf);           
  }
//+------------------------------------------------------------------+
//| Ïðè ëþáîì äðóãîì äëÿ âñåõ ïîçèöèé ñ÷åòà                          |
//+------------------------------------------------------------------+
double getDayProfit(int mode, int dayShift)
  {
   int t, cnt1, cyear, cmonth, cday;
   double pf;
   datetime ctm;
   t = HistoryTotal();
   pf = 0;
   for(cnt1 = 0; cnt1 < t; cnt1++)
     {
       OrderSelect(cnt1, SELECT_BY_POS, MODE_HISTORY);
       ctm = OrderCloseTime();
       cyear = TimeYear(ctm);
       cmonth = TimeMonth(ctm);
       cday = TimeDay(ctm);
       if(cyear == Year() && cmonth == Month() && cday == (Day() - dayShift))
         {                 
           if(mode == 1)
             {      
               //ïðèáûëü ïî ëîíãàì è øîðòàì
               if(OrderType() == OP_BUY || OrderType() == OP_SELL) 
                 {
                   pf = pf + OrderProfit() + OrderSwap() + OrderCommission();           
                 }
             } 
           else 
             {
               if(mode == 2 && OrderType() == OP_BUY) 
                 { 
                   //ïðèáûëü òîëüêî ïî ëîíãàì
                   pf = pf + OrderProfit() + OrderSwap() + OrderCommission();
                 }
               if(mode == 3 && OrderType() == OP_SELL)
                 { 
                   //ïðèáûëü òîëüêî ïî øîðòàì
                   pf = pf + OrderProfit() + OrderSwap() + OrderCommission();                        
                 }   
             }      
         } 
     }  
   return (pf);           
  }
//+------------------------------------------------------------------+
//|  Ðàñ÷åò öåíû, ïî êîòîðîé âûñòàâëÿåòñÿ îðäåð SellStop             |
//+------------------------------------------------------------------+
double setPriceSellStop()
  {
   double topPrice, PriceSetka, HighestPriceInRange;
   int NumPoloski, NumBarsAfterOpenedOrder;
   datetime OpenOrderTime;
   if(mode_work == 0)
     {
       topPrice = getOrderPriceByNum(getMaxShortNum());
       OpenOrderTime = getOrderOpenTimeByNum(getMaxShortNum());
     }
   if(mode_work ==1 )
     {
       topPrice = getOrderPriceByNum(getMaxLongNum());
       OpenOrderTime = getOrderOpenTimeByNum(getMaxLongNum());
     }
   NumBarsAfterOpenedOrder = iBarShift(NULL, 0, OpenOrderTime, false);         
   HighestPriceInRange = Highest(NULL, 0, MODE_HIGH, NumBarsAfterOpenedOrder, 0);
// íîìåð ïîëîñêè ïîä òåêóùåé öåíîé BID
   NumPoloski = MathAbs(MathFloor((Bid - topPrice) / (Step*Point)));
// çíà÷åíèå öåíû, ñîîòâåòñòâóþùåå ýòîé ïîëîñêå 
   PriceSetka = topPrice + NumPoloski*Step*Point;
   if(HighestPriceInRange < PriceSetka + Step*Point && 
      PriceSetka >= topPrice + Step*Point && Bid > topPrice)   
     {
       return(NormalizeDouble(PriceSetka - Step*Point, Digits));
     }                
  }
//+------------------------------------------------------------------+
//| Ðàñ÷åò öåíû, ïî êîòîðîé âûñòàâëÿåòñÿ îðäåð BuyStop               |
//+------------------------------------------------------------------+
double setPriceBuyStop()
  {
   double lowPrice, PriceSetka, LowestPriceInRange;
   int NumPoloski, NumBarsAfterOpenedOrder;
   datetime OpenOrderTime;
   if(mode_work == 0)
     {         
       lowPrice = getOrderPriceByNum(getMaxLongNum());
       OpenOrderTime = getOrderOpenTimeByNum(getMaxLongNum());
     }
   if(mode_work == 1)
     {
       lowPrice = getOrderPriceByNum(getMaxShortNum());
       OpenOrderTime = getOrderOpenTimeByNum(getMaxShortNum());
     }
   NumBarsAfterOpenedOrder = iBarShift(NULL, 0, OpenOrderTime, false);         
   LowestPriceInRange = Lowest(NULL, 0, MODE_LOW, NumBarsAfterOpenedOrder, 0);
// íîìåð ïîëîñêè íàä òåêóùåé öåíîé ASK
   NumPoloski = MathAbs(MathFloor((lowPrice - Ask) / (Step*Point)));

   PriceSetka = lowPrice - NumPoloski*Step*Point;
// çíà÷åíèå öåíû, ñîîòâåòñòâóþùåå ýòîé ïîëîñêå    
   if(LowestPriceInRange > PriceSetka - Step*Point && 
      PriceSetka <= lowPrice - Step*Point && Ask < lowPrice)   
     {
       return(NormalizeDouble(PriceSetka + Step*Point,Digits));
     }
  }
//+------------------------------------------------------------------+
//| Ôóíêöèÿ çàêðûòèÿ îðäåðîâ ïî äîñòèæåíèþ ïðîôèòà                   |
//+------------------------------------------------------------------+
bool getProfitOrdersClose()
  {
   int cnt1, err, tic1,tic2, LotBy, LotBy1, i;
   bool ticdone;    
   int T_sell[10], T_buy[10], a;  
   a = 0;
   for(cnt1 = 0; cnt1 < OrdersTotal(); cnt1++)
     {
       //ïðîâåðÿåì, ìîæíî ëè çàêðûòü âñòðå÷íûå îðäåðà áåç ïîòåðè ñïðåäà
       OrderSelect(cnt1, SELECT_BY_POS);         
       tic1 = OrderTicket(); 
       LotBy = OrderLots();
       if(OrderType() == OP_SELL)
         {           
           for(i = 0; i < OrdersTotal(); i++)
             {
               OrderSelect(i, SELECT_BY_POS);             
               tic2 = OrderTicket(); 
               LotBy1 = OrderLots();
               if(OrderType() == OP_BUY && LotBy == LotBy1 && 
                  OrderSelect(tic1, SELECT_BY_TICKET) && 
                  OrderSelect(tic2, SELECT_BY_TICKET))
                 {                
                   T_sell[a] = tic1;
                   T_buy[a] = tic2;                    
                   a++;
                 }
             }
         }
     } 
   for(cnt1 = 0; cnt1 < a; cnt1++)
     {
       // çàêðûâàåì âñòðå÷íûå îðäåðà
       if(OrderSelect(T_sell[cnt1], SELECT_BY_TICKET) && 
          OrderSelect(T_buy[cnt1], SELECT_BY_TICKET))
         {
           ticdone = OrderCloseBy(T_sell[cnt1], T_buy[cnt1], Green);        
           if(!ticdone)
             {
               err = GetLastError(); 
               Print("Îøèáêà çàêðûòèÿ âñòðå÷íîãî îðäåðà = ", ErrorDescription(err), 
                     "¹ òèêåòà (sell)= ", T_sell[cnt1], "¹ òèêåòà (buy)= ", T_buy[cnt1]);
             }            
         }
     }   
   for(cnt1 = OrdersTotal(); cnt1 >= 0; cnt1--)
     {
       // çàêðûâàåì âñå îñòàâøèåñÿ îðäåðà
       OrderSelect(cnt1, SELECT_BY_POS, MODE_TRADES);
       if(OrderSymbol() == Symbol())
         {
           if(OrderType() == OP_BUY)
             {
               ticdone = OrderClose(OrderTicket(), OrderLots(), Ask, 5, Green);
               if(ticdone) 
                   PlaySound("timeout.wav");
               if(!ticdone)
                 {
                   err = GetLastError(); 
                   if(err != 0) 
                   Print("Îøèáêà çàêðûòèÿ îðäåðà = ", ErrorDescription(err));
                 }            
             }
           if(OrderType() == OP_SELL)
             {
               ticdone = OrderClose(OrderTicket(), OrderLots(), Bid, 5, Green);
               if(ticdone) 
                   PlaySound("timeout.wav");
               if(!ticdone)
                 {
                   err = GetLastError(); 
                   if(err != 0) 
                       Print("Îøèáêà çàêðûòèÿ îðäåðà = ", ErrorDescription(err));
                 }           
             }
         }
     }  
   return (False);       
  }
//+------------------------------------------------------------------+
//| Âçâåøåííàÿ öåíà äëÿ âñåõ ïîçèöèé â îäíó ñòîðîíó äëÿ âû÷èñëåíèÿ   |
//| çíà÷åíèÿ òåéêïðîôèòà âñåé ñåðèè                                  |
//+------------------------------------------------------------------+
double getSumWeightedPrice(int mode)
  {
   int i;
   double sumWeightedPrice;
   for(i=0;i<=OrdersTotal();i++)
     {
       OrderSelect(i,SELECT_BY_POS);
       if(OrderType() == OP_BUY && mode == 1)
         {
           sumWeightedPrice = sumWeightedPrice + OrderLots()*OrderOpenPrice();
         }
       if(OrderType() == OP_SELL && mode == 2)
         {
           sumWeightedPrice = sumWeightedPrice+OrderLots()*OrderOpenPrice();
         }   
      }
   return(sumWeightedPrice);
  }
//+------------------------------------------------------------------+
//| Îïðåäåëåíèå öåíû çàêðûòèÿ âñåõ îðäåðîâ, íåîáõîäèìîé äëÿ          |
//| âûñòàâëåíèÿ òåéêïðîôèòîâ è ñòîïëîññîâ äëÿ îðäåðîâ                |
//+------------------------------------------------------------------+
double getOptimalTakeProfit(double multiplier, bool SELL_BUY)
  {
//ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
   double TempOptimalTP, TempOptimalTP_sell, TempOptimalTP_buy, NeedTP_points, lots;
   int i;
   double profit_money, price_tick;    
   profit_money = AccountBalance()*ProfitPercent*multiplier / 100;
   price_tick = MarketInfo(Symbol(), MODE_TICKVALUE);
// íåîáõîäèìîå êîëè÷åñòâî ïóíêòîâ (ïðè ëîòå=1) äëÿ äîñòèæåíèÿ ïðîôèòà
   NeedTP_points = profit_money*Point / price_tick;
   lots = getBuyLotsSum(1) + getSellLotsSum(1);
   if(getSellLotsSum(1) != 0)   
     {
       TempOptimalTP_sell = (getSumWeightedPrice(2) - NeedTP_points) / getSellLotsSum(1);
     }
   else 
     {
       // áåç ó÷åòà îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
       TempOptimalTP_sell = 0;
     }
   if(getBuyLotsSum(1) != 0)   
     {
       TempOptimalTP_buy = (getSumWeightedPrice(1) + NeedTP_points) / getBuyLotsSum(1);
     }
   else 
     {
       // áåç ó÷åòà îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
       TempOptimalTP_buy = 0;
     }             
   if(!SELL_BUY)
     {  
       if(getBuyLotsSum(1) == getSellLotsSum(1))
         {
           TempOptimalTP = TempOptimalTP_buy;
         }
       else
         {  
           if(lots != 0)
             {
               TempOptimalTP = (TempOptimalTP_buy*getBuyLotsSum(1) + 
                                TempOptimalTP_sell*getSellLotsSum(1) + 
                                NeedTP_points) / lots;
             }
           else 
             {
               TempOptimalTP = 0;
             }
         }                 
       //ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
       return(NormalizeDouble(TempOptimalTP_buy, Digits));
     }
   if(SELL_BUY)
     {  
       if(getBuyLotsSum(1) == getSellLotsSum(1))
         {
           TempOptimalTP = TempOptimalTP_sell;
         }
       else
         {  
           if(lots != 0)
             {
               TempOptimalTP = (TempOptimalTP_buy*getBuyLotsSum(1) + 
                                TempOptimalTP_sell*getSellLotsSum(1) - 
                                NeedTP_points) / lots;
             }
           else 
             {
               TempOptimalTP = 0;
             }
         }                
       //ñ ó÷åòîì îòêðûòîãî ïðîòèâîïîëîæíîãî ïëå÷à
       return(NormalizeDouble(TempOptimalTP_sell,Digits));           
     }           
  }   
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void setPendingOrders(int mode)
  {
   int i, start, err;
   bool ticket;
   double lot;
// ïðîáîéíûé ðåæèì
   if(mode == 0)
     {
       //âûñòàâëÿåì îðäåðà äëÿ ëîíãîâ
       if(getTopLevel(1) < maxLevel && !isMgNum(100))
         {   
           for(i = 1; i < 12; i++)
             {
               if(getTopLevel(1) == i && isMgNum(getNum(1, i+1)) == False && 
                  isOrderActive(getNum(1, i)) == True && setPriceBuyStop() != 0 &&
                  getOrderPriceByNum(getMaxLongNum()) != setPriceBuyStop()) 
                 {
                   start = GetTickCount();                                  
                   ticket = OrderSend(Symbol(), OP_BUYSTOP, 
                                      getLotByLevel(getTopLevel(1) + 1),
                                      setPriceBuyStop(), 3, 0, 0,
                                      StringConcatenate(i + 1, " ëîíã"), 
                                      getNum(1, i + 1), 0, Green);
                   if(ShowLog)
                     {
                       Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
                             " ñåêóíä.");                         
                     }
                   if(ticket) 
                       PlaySound("alert.wav");
                   if(!ticket) 
                     {
                       err = GetLastError(); 
                       Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                     }                
                   return(1);
                 } 
             }
         } 
       //âûñòàâëÿåì îðäåðà äëÿ øîðòîâ
       if(getTopLevel(2) < maxLevel && !isMgNum(101))
         {    
           for(i = 1; i < 12; i++)
             {
               if(getTopLevel(2) == i && isMgNum(getNum(0, i + 1)) == False && 
                  isOrderActive(getNum(0, i)) == True && setPriceSellStop() != 0 && 
                  getOrderPriceByNum(getMaxShortNum()) != setPriceSellStop()) 
                 {
                   start = GetTickCount();                 
                   ticket = OrderSend(Symbol(), OP_SELLSTOP, 
                                      getLotByLevel(getTopLevel(2) + 1),
                                      setPriceSellStop(), 3, 0, 0,
                                      StringConcatenate(i + 1, " øîðò"),
                                      getNum(0, i + 1), 0, Red);                 
                   if(ShowLog)
                     {
                       Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
                             " ñåêóíä.");                        
                     }
                   if(ticket) 
                       PlaySound("alert.wav");
                   if(!ticket) 
                     {
                       err = GetLastError(); 
                       Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                     }                
                   return(1);
                 } 
             }
         }
     }      
// îòáîéíûé ðåæèì
   if(mode == 1)
     {
       //âûñòàâëÿåì îðäåðà äëÿ ëîíãîâ
       if(getTopLevel(1) < maxLevel)
         {   
           for(i = 1; i < 12; i++)
             {
               if(getTopLevel(2) == i && isMgNum(getNum(0, i + 1)) == False && 
                  isOrderActive(getNum(0, i)) == True && setPriceBuyStop() != 0 && 
                  getOrderPriceByNum(getMaxShortNum())!= setPriceBuyStop()) 
                 {
                   //÷òîáû íå áûëî ëîêîâ - getTopLevel(1)
                   start = GetTickCount();
                   lot = getLotByLevel(getTopLevel(1) + 1);
                   if(lot > MarketInfo(Symbol(), MODE_MAXLOT)) 
                     {
                       lot = MarketInfo(Symbol(), MODE_MAXLOT);
                     }
                   ticket = OrderSend(Symbol(), OP_SELLLIMIT, lot, setPriceBuyStop(),
                                      3, 0, 0, StringConcatenate(i + 1, " øîðò"), 
                                      getNum(0,i+1),0,Green);
                   if(ShowLog)
                     {
                       Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000,
                             " ñåêóíä.");                         
                     }
                   if(ticket) 
                       PlaySound("alert.wav");
                   if(!ticket) 
                     {
                       err = GetLastError(); 
                       Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                     }                
                   return(1);
                 } 
             }
         } 
       //âûñòàâëÿåì îðäåðà äëÿ øîðòîâ
       if(getTopLevel(2) < maxLevel)
         {    
           for(i = 1; i < 12; i++)
             {
               if(getTopLevel(1) == i && isMgNum(getNum(1, i + 1)) == False && 
                  isOrderActive(getNum(1, i)) == True && setPriceSellStop() != 0 && 
                  getOrderPriceByNum(getMaxLongNum()) != setPriceSellStop()) 
                 {
                   start = GetTickCount();                 
                   // ÷òîáû íå áûëî ëîêîâ - getTopLevel(2)
                   lot = getLotByLevel(getTopLevel(2) + 1);
                   if(lot > MarketInfo(Symbol(), MODE_MAXLOT)) 
                     {
                       lot = MarketInfo(Symbol(), MODE_MAXLOT);
                     }
                   ticket = OrderSend(Symbol(), OP_BUYLIMIT, lot, setPriceSellStop(), 
                                      3, 0, 0, StringConcatenate(i + 1, " ëîíã"), 
                                      getNum(1, i + 1), 0, Red);                
                   if(ShowLog)
                     {
                       Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000, 
                             " ñåêóíä.");                        
                     }
                   if(ticket) 
                       PlaySound("alert.wav");
                   if(!ticket) 
                     {
                       err = GetLastError(); 
                       Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
                     }                
                   return(1);
                 } 
             }
         }
     }      
  }     
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void setTrailingStop(int trailingSL, double multiplier)
  {
   int cnt1, t, s;
   double PriceSL,spread, temp;         
   t = OrdersTotal();
   s = MarketInfo(Symbol(), MODE_SPREAD);
   spread = s*Point;     
   if((AccountEquity() - AccountBalance()) > AccountBalance()*ProfitPercent*multiplier / 100)
     {           
       if(getBuyLotsSum(1) > getSellLotsSum(1))
         {  
           PriceSL = Bid - Point*trailingSL;
           if(mode_work == 0)
             {
               temp = Bid - getOrderPriceByNum(getMaxLongNum());
             }
           else 
             {
               temp = Bid - getOrderPriceByNum(getMaxShortNum());
             }
           if(temp > Point*trailingSL)
             {
               if(OrderStopLoss() < PriceSL && mode_work == 0)
                 { 
                   for(cnt1 = 0; cnt1 < t; cnt1++)
                     {
                       OrderSelect(cnt1, SELECT_BY_POS);
                       if(OrderType() == OP_BUY)
                         {
                           if(PriceSL > Bid)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL, 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           PriceSL, OrderTakeProfit(), 0, Green);
                             }
                         }
                       if(OrderType() == OP_SELL)
                         {
                           if(PriceSL > Bid)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           PriceSL + spread, OrderTakeProfit(),
                                           0, Green);
                             }                                
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL + spread, 0, Green);
                             }
                         }
                     }                       
                 }
               if(OrderStopLoss() > PriceSL && mode_work == 1 || OrderStopLoss() == 0)
                 {  
                   for(cnt1 = 0; cnt1 < t; cnt1++)
                     {
                       OrderSelect(cnt1, SELECT_BY_POS);
                       if(OrderType() == OP_BUY)
                         {
                           if(PriceSL > Bid)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL, 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL, 
                                           OrderTakeProfit(), 0, Green);
                             }
                         }
                       if(OrderType() == OP_SELL)
                         {
                           if(PriceSL > Bid)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                               PriceSL + spread, OrderTakeProfit(), 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL + spread, 0, Green);
                             }
                         }
                     }                       
                 }                          
             }                    
         }    
       if(getBuyLotsSum(1) < getSellLotsSum(1))
         {                               
           PriceSL = Ask + Point*trailingSL;
           if(mode_work == 0)
             {
               temp = getOrderPriceByNum(getMaxShortNum()) - Ask;
             }
           else
             {
               temp = getOrderPriceByNum(getMaxLongNum()) - Ask;
             }
           if(temp > Point*trailingSL)
             {                     
               if(OrderStopLoss() > PriceSL || OrderStopLoss() == 0 && mode_work == 0)
                 { 
                   for(cnt1 = 0; cnt1 < t; cnt1++)
                     {
                       OrderSelect(cnt1, SELECT_BY_POS);
                       if(OrderType() == OP_BUY)
                         {
                           if(PriceSL > Ask)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL-spread, 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           PriceSL - spread, OrderTakeProfit(), 0, Green);
                             }
                         }
                       if(OrderType() == OP_SELL)
                         {
                           if(PriceSL > Ask)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL,
                                           OrderTakeProfit(), 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL, 0, Green);
                             }
                         }
                     }                                                
                 }
               if(OrderStopLoss() < PriceSL && mode_work == 1)
                 { 
                   for(cnt1 = 0; cnt1 < t; cnt1++)
                     {
                       OrderSelect(cnt1, SELECT_BY_POS);
                       if(OrderType() == OP_BUY)
                         {
                           if(PriceSL > Ask)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL - spread, 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           PriceSL - spread, OrderTakeProfit(), 0, Green);
                             }
                         }
                       if(OrderType() == OP_SELL)
                         {
                           if(PriceSL > Ask)
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), PriceSL,
                                           OrderTakeProfit(), 0, Green);
                             }
                           else 
                             {
                               OrderModify(OrderTicket(), OrderOpenPrice(), 
                                           OrderStopLoss(), PriceSL, 0, Green);
                             }
                         }
                     }                                                
                 }
             }                     
         }  
     
     }    
  }
//+------------------------------------------------------------------+
//|  Breakdowning martingail™  v 1.0.2                               |
//+------------------------------------------------------------------+
int start()
  {
   double s, spread, Risk, level, LotsDifferent, lot_buy, lot_sell, 
          multiplier, forstep;
   int total, err, i, start, cnt1;   
   string level_str, mode;
   bool ticket; 
   s = MarketInfo(Symbol(), MODE_SPREAD);
   spread = s*Point;   
   total = OrdersTotal();
   LotsDifferent = MathAbs(getBuyLotsSum(1) - getSellLotsSum(1));     
   if(MinMaxStepMode == 0)
     {
       Step = Step;
     }
   if(MinMaxStepMode == 1)
     {
       Step = MathCeil((AccountBalance() - AccountEquity() + 1)*100000 / AccountBalance());
       if(Step < 15)
         {
           Step = 15;
         }
       if(Step > 40)
         {
           Step = 40;
         }
     }
   if(MinMaxStepMode == 2)
     {      
       forstep = MathPow(AccountBalance() / AccountEquity(), 4);
       Step = MathCeil(forstep*15);
     }
   if(AccountEquity() / AccountBalance() < 0.7)
     {
       mode_work = 1;
     }
   else
     {
       mode_work = 0;
     }
// Âêëþ÷åíèå ìàíèìåíåäæìåíòà (âû÷èñëåíèå ëîòîâ)        
   if(MoneyManagement == true && LogariphmicMM == true)
     {              
       Risk = MathCeil(Riskfactor*100 / MathSqrt(AccountBalance()));
       if(Risk > 20) 
           Risk = 20;             
       startLots = MathCeil(AccountBalance()*Risk / 10000) / 10;               
       if(startLots > MarketInfo(Symbol(), MODE_MAXLOT)) 
         {
           startLots = MarketInfo(Symbol(), MODE_MAXLOT);
         }
       if(startLots < MarketInfo(Symbol(), MODE_MINLOT)) 
         {
           startLots = MarketInfo(Symbol(), MODE_MINLOT);
         }
     }
   if(MoneyManagement == true && LogariphmicMM == false)
     {
       startLots = NormalizeDouble(AccountBalance()*Riskfactor / 100000, 1);
       if(startLots > MarketInfo(Symbol(), MODE_MAXLOT)) 
         {
           startLots = MarketInfo(Symbol(), MODE_MAXLOT);
         }
       if(startLots < MarketInfo(Symbol(), MODE_MINLOT)) 
         {
           startLots = MarketInfo(Symbol(), MODE_MINLOT);
         }
     }     
   if(MoneyManagement == false && LogariphmicMM == false)    
     {
       startLots  =startLots;
     }
//Îïðåäåëÿåì, áóäåì ëè èñïîëüçîâàòü OptimalTakePrifit            
   if(OptimalTakeProfit) 
     {
       multiplier = MathSqrt(LotsDifferent);
     }
   if(!OptimalTakeProfit) 
     {
       multiplier = 1;
     }         
//Îïðåäåëÿåì, áóäåì ëè èñïîëüçîâàòü NoTradeBeforeNewDay
   if(getDayProfit(1, 0) > 0 && NoTradeBeforeNewDay)
     {
       TradeAllowed = false;
     }
   if(getDayProfit(1, 0) == 0 && NoTradeBeforeNewDay)
     {
       TradeAllowed = true;
     }
//Ðàñïå÷àòêà ðàçëè÷íîé èíôîðìàöèè íà ýêðàíå       
   if(getBuyLotsSum(1) > getSellLotsSum(1))   
     {
       level = getOptimalTakeProfit(multiplier, false) - spread;
     }
   if(getBuyLotsSum(1) < getSellLotsSum(1))   
     {
       level = getOptimalTakeProfit(multiplier, true) + spread;
     }
   if(level != 0)
     {
       level_str = DoubleToStr(level, Digits);
     }
   else 
     {
       //ðàñïå÷àòêà óðîâíÿ çàêðûòèÿ âñåõ îðäåðîâ
       level_str=" ïîêà íåò, æäåì...";
     }
   if(mode_work == 0)
     {
       mode = "ïðîáîé (îðäåðà BuyStop è SellStop)";
     }
   if(mode_work == 1)
     {
       mode = "îòáîé  (îðäåðà BuyLimit è SellLimit)";
     }
   ObjectSetText("label_object1", StringConcatenate("Ïëàíèðóåìûé óðîâåíü çàêðûòèÿ ñåðèè ïî ",
                 Symbol(), ": ", level_str), 9, "Lucida Console", NavajoWhite);
   ObjectSetText("label_object2", StringConcatenate("Ðåæèì ðàáîòû : ", mode), 9, 
                 "Lucida Console", NavajoWhite);
   Comment("\n", "\n", "\n",
           "    Ïðîôèò ïî ëîíãàì  = ", NormalizeDouble(getAllProfit(2), 2), " $", "\n",
           "    Ïðîôèò ïî øîðòàì = ", NormalizeDouble(getAllProfit(3), 2), " $", "\n",
           "    ---------------------------------------------------", "\n",
           "    Ïðîôèò ñåãîäíÿ     = ", NormalizeDouble(getDayProfit(1, 0), 2), " $", "\n",
           "    Ïðîôèò â÷åðà       = ", NormalizeDouble(getDayProfit(1, 1), 2), " $", "\n",
           "    Ïðîôèò ïîçàâ÷åðà = ", NormalizeDouble(getDayProfit(1, 2), 2), " $", "\n",
           "    ---------------------------------------------------", "\n",
           "    Balance       = ",NormalizeDouble(AccountBalance(),2), " $", "\n",
           "    Equity         = ",NormalizeDouble(AccountEquity(),2), " $", "\n",
           "    Free Margin = ", NormalizeDouble(AccountFreeMargin(),2), " $", "\n",
           "    ---------------------------------------------------", "\n",
           "    Sell Lots = ", getSellLotsSum(1), "   |   Buy Lots = ", getBuyLotsSum(1), "\n",
           "    ---------------------------------------------------", "\n",
           "    Êðåäèòíîå ïëå÷î ñ÷¸òà  1:", AccountLeverage());
// Åñëè òîðãîâëÿ íå ðàçðåøåíà, è íåò ïåðâè÷íûõ îðäåðîâ - âûõîä         
   if(isMgNum(getNum(1, 1)) == False && isMgNum(getNum(1, 1)) == False && !TradeAllowed)
     {
       return;
     }
//âûñòàâëåíèå ïåðâûõ îðäåðîâ ñåðèè, åñëè òàêèõ åùå íåò
   if(isMgNum(getNum(1, 1)) == False && TradeAllowed) 
     {
       start = GetTickCount();
       ticket = OrderSend(Symbol(), OP_BUY, getLotByLevel(1), NormalizeDouble(Ask, Digits), 
                          3, 0, 0, "ïåðâàÿ ëîíã", getNum(1, 1), 0, Green);
       if(ShowLog)
         {
           Print("Îòêðûòèå ïåðâîé ïîçèöèè ñåðèè ëîíãîâ ", Symbol(), " ask= ", Ask, 
                 " ticket=", ticket);
           Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000, " ñåêóíä.");  
         }                     
       if(ticket) 
           PlaySound("alert.wav");
       if(!ticket) 
         {
           err = GetLastError(); 
           Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
         }                
     }
   if(isMgNum(getNum(0, 1)) == False && TradeAllowed) 
     {
       start = GetTickCount();
       ticket = OrderSend(Symbol(), OP_SELL, getLotByLevel(1), NormalizeDouble(Bid, Digits),
                          3, 0, 0, "ïåðâàÿ øîðò", getNum(0, 1), 0, Green);
       if(ShowLog)
         {
           Print("Îòêðûòèå ïåðâîé ïîçèöèè ñåðèè øîðòîâ ", Symbol(), " Bid= ", Bid, 
                 " ticket=", ticket);
           Print("Âðåìÿ îòêðûòèÿ îðäåðà ", (GetTickCount() - start) / 1000, " ñåêóíä.");  
         }
       if(ticket) 
           PlaySound("alert.wav");               
       if(!ticket) 
         {
           err = GetLastError(); 
           Print("Îøèáêà = ", err, " (", ErrorDescription(err), ")");
         }                
     }            
//âûñòàâëÿåì îòëîæåííûé îðäåð, åñëè åñëè åñòü âîçìîæíîñòü
   setPendingOrders(mode_work);
//ìîäèôèêàöèÿ îòëîæåííûõ îðäåðîâ BuyStop è SellStop (BuyLimit è SellLimit ïðè mode_work = 1)
   if(mode_work == 0)
     {      
       if(getOrderPriceByNum(getNextOrderNum(getMaxShortNum())) < setPriceSellStop() && 
          setPriceSellStop() != 0)
         { 
           //äëÿ øîðòîâ
           modOrder(getNextOrderNum(getMaxShortNum()), setPriceSellStop(), 0);
         }
       if(getOrderPriceByNum(getNextOrderNum(getMaxLongNum())) > setPriceBuyStop() && 
          setPriceBuyStop()!=0)
         { 
           //äëÿ ëîíãîâ
           modOrder(getNextOrderNum(getMaxLongNum()),setPriceBuyStop(),0); 
         }
     }
   if(mode_work == 1)
     {      
       if(getOrderPriceByNum(getNextOrderNum(getMaxLongNum())) < setPriceSellStop() && 
          setPriceSellStop() != 0)
         { 
           modOrder(getNextOrderNum(getMaxLongNum()), setPriceSellStop(), 0);
         }
       if(getOrderPriceByNum(getNextOrderNum(getMaxShortNum())) > setPriceBuyStop() && 
          setPriceBuyStop() != 0)
         { 
           modOrder(getNextOrderNum(getMaxShortNum()), setPriceBuyStop(), 0);
         }
     }
// óñëîâèÿ äëÿ ôèêñàöèè ïðèáûëè
   if(MathAbs(getBuyLotsSum(1) - getSellLotsSum(1)) < 0.2 && 
      (isOrderActive(getNum(0, 2)) || isOrderActive(getNum(1, 2))))
     {
       // åñëè ñóììà ëîòîâ â ðàçíûå ñòîðîíû ïðèìåðíî îäèíàêîâà - 
       // çàêðûâàåì âñòðå÷íûìè îðäåðàìè (îáíóëÿåì íà÷àëüíûé óðîâåíü)
       getProfitOrdersClose();                              
     }
   if(getAllProfit(1) > AccountBalance()*ProfitPercent*multiplier / 100 && TrailingStop == 0)
     {
       //ïðè äîñòèæåíèè íåîáõîäèìîãî ïðîôèòà çàêðûâàåì âñå îðäåðà                              
       getProfitOrdersClose();                              
     }           
   if(TrailingStop != 0)
     {
       // òðåéëèì ïðèáûëü, åñëè îíà åñòü 
       setTrailingStop(TrailingStop, multiplier);
     }
// óäàëåíèå âñåõ ëèøíèõ îðäåðîâ â ñëó÷àå, åñëè ñåðèÿ çàêðûëàñü ïðîôèòîì, 
// ò.å. åñëè íåò îòêðûòûõ îðäåðîâ ïåðâîé ñòóïåíè
// óäàëåíèå ëèøíèõ ëîíãîâ, åñëè íåò îðäåðà ïåðâîé ñòóïåíè           
   if(isOrderActive(getNum(1, 1)) == False)
     {
       for(i = getNum(1, 2); i < getNum(1, 9); i += 10)
         {
           //íà÷èíàåì ïåðåáèðàòü âñå ñî âòîðîãî óðîâíÿ
           deleteOrderNum(i);
         }          
     }           
   if(isOrderActive(getNum(0, 1)) == False)
     {
       //äëÿ øîðòîâ
       for(i = getNum(0, 2); i < getNum(0, 9); i+=10)
         {
           deleteOrderNum(i);
         }          
     }
   return(0);
  }         
//+------------------------------------------------------------------+