Master_MM_Droid

//+------------------------------------------------------------------+
//|                                             "Master_MM_Droid.mq4"|
//|     Ïóáëè÷íàÿ áåñïëàòíàÿ âåðñèÿ 2.4 äëÿ http://codebase.mql4.com |
//|                              Copyright © 2013, Musa Esmagambetov |
//|                                                   cocaine@nxt.ru |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2013, Musa Esmagambetov"
#property link      "cocaine@nxt.ru"
//+------------------------------------------------------------------+
// êîíôèãóðàöèÿ óïðàâëåíèÿ êàïèòàëîì (ÌÌ):
#define mm_math_sqrt       1                  // êâàäðàòíûé êîðåíü îò äåïîçèòà
#define mm_percent         2                  // ïðîöåíò äåïîçèòà
#define mm_martingale      3                  // ìàðòèíãåéë
#define mm_antimartingale  4                  // àíòèìàðòèíãåéë
#define mm_rajan_jones     5                  // ìåòîä Ðàéàíà Äæîíñà
#define mm_larry_williams  6                  // ìåòîä Ëàððè Âèëüÿìñà
#define mm_second_chance   7                  // çàùèùåííûé (ÒÑ ñëèâàåò)
#define mm_f2stop          8                  // 2%
#define mm_test            9                  // òåñòîâûé ðåæèì äëÿ íîâûõ ìåòîäîâ
//+------------------------------------------------------------------+
//extern int mm_user_mode = 1;   //Âûáîð ïîëüçîâàòåëåì ðåæèìà ÌÌ
//+------------------------------------------------------------------+
extern int time_shift = 2;       //Âðåìåííîé ñäâèã êîòèðîâîê áðîêåðà îò GMT
int start_hour = 0;              //Ñòàðòîâûé ÷àñ
//+------------------------------------------------------------------+
extern int mm_rsi_mode = 1;                 //Ðåæèì ÌÌ äëÿ ÒÑ "RSI"
extern int mm_boxes_mode = 1;               //Ðåæèì ÌÌ äëÿ ÒÑ "Ïðîðûâ êîðîáêè"
extern int mm_weekly_mode = 1;              //Ðåæèì ÌÌ äëÿ ÒÑ "Ëåíèâûé òðåéäåð"
extern int mm_gap_mode = 1;                 //Ðåæèì ÌÌ äëÿ ÒÑ "Ãýï ïîíåäåëüíèêà"
//+------------------------------------------------------------------+
string mm_names[] ={"ÌÌ îòêëþ÷åí, òîðãè ìèíèìàëüíûì ëîòîì","20% êâàäðàòíîãî êîðíÿ îò äåïîçèòà",
"ïðîöåíò îò äåïîçèòà","ìàðòèíãåéë","àíòèìàðòèíãåéë","ïî Ðàéàíó Äæîíñó","ìåòîä Ëàððè Âèëüÿìñà","çàùèùåííûé (ÒÑ ñëèâàåò)",
"2 ïðîöåíòà","òåñò"};
 
//ñ÷åò÷èêè äëÿ ðàñ÷åòîâ ÌÌ ïî ìàðòèíãåéëó, àíòèìàðòèíãåéëó è ìåòîäó Ðàéàíà Äæîíñà
int martingale_count=1, antimartingale_count=0, rajan_jones_count = 0;
//+------------------------------------------------------------------+
double risk = 0.05;              //óðîâåíü ðèñêà äëÿ ðàñ÷åòîâ ÌÌ ïî Ëàððè Âèëüÿìñà è ïðîöåíòó îò äåïîçèòà
double delta = 500;              //Äåëüòà äëÿ ðàñ÷åòîâ ÌÌ ïî ìåòîäó Ðàéàíà Äæîíñà
//+------------------------------------------------------------------+
double start_virtual_balance[4]; //ìàññèâ íà÷àëüíûõ áàëàíñîâ äëÿ çàïóñêà ðàñ÷åòîâ ÌÌ
//+------------------------------------------------------------------+
double rajan_jones_level;        //áàëàíñ äëÿ ðàñ÷åòîâ ÌÌ ïî ìåòîäó Ðàéàíà Äæîíñà
double martingale_balance;       //áàëàíñ äëÿ ðàñ÷åòîâ ÌÌ ìàðòèíãåéëà
double antimartingale_balance;   //áàëàíñ äëÿ ðàñ÷åòîâ ÌÌ àíòèìàðòèíãåéëà
double virtual_deposit;          //âèðòóàëüíûé äåïîçèò, äèíàìè÷åñêèé èñïîëüçóåòñÿ â ðàñ÷åòàõ ÌÌ äëÿ êàæäîé ÒÑ
double balance_separator = 0.25; //ðàçäåëèòåëü ðåàëüíîãî áàëàíñà íà 4 âèðòóàëüíûõ
//+------------------------------------------------------------------+
#define rsi_magic    50          //ìàãè÷åñêèé íîìåð è òðåéëèíã ñòîï ÒÑ "RSI"
#define boxes_magic  35          //ìàãè÷åñêèé íîìåð è òðåéëèíã ñòîï ÒÑ "Ïðîðûâ êîðîáêè"
#define weekly_magic 100         //ìàãè÷åñêèé íîìåð è òðåéëèíã ñòîï ÒÑ "Ëåíèâûé òðåéäåð"
#define gap_magic    115         //ìàãè÷åñêèé íîìåð è òðåéëèíã ñòîï ÒÑ "Ãýï ïîíåäåëüíèêà"
//+------------------------------------------------------------------+
int orders_limit = 3;            //êîëè÷åñòâî îðäåðîâ äëÿ ÒÑ "RSI"
int dif = 15;                    //ñìåùåíèå â ïóíêòàõ äëÿ ÒÑ "RSI"
double min_lot = 0.1;            //ìèíèìàëüíûé ëîò, çíà÷åíèå ñóãóáî äëÿ èíèöèàëèçàöèè, çäåñü íå ìåíÿòü!
//+--------------------------òîðãîâûå ñèãíàëû----------------------------------------+
#define sell_signal        -11    //ñèãíàë íà ïðîäàæó
#define buy_signal          11    //ñèãíàë íà ïîêóïêó
#define no_signal           0     //ñèãíàë âíå ðûíêà, çàïóñêàåò òðåéëèíã
#define close_buy           22    //ñèãíàë íà çàêðûòèå ïîêóïîê
#define close_sell         -22    //ñèãíàë íà çàêðûòèå ïðîäàæ
#define error_signal        33    //ñèãíàë î íàëè÷èè îøèáêè
#define clear_signal        44    //ñèãíàë óäàëåíèÿ íåñðàáîòàâøèõ îðäåðîâ
#define set_stops           55    //ñèãíàë âûñòàâëåíèÿ îðäåðîâ íà ãðàíèöàõ êîðîáêè
#define weekly_open         66    //ñèãíàë âûñòàâëåíèÿ îðäåðîâ íà ãðàíèöàõ êîðîáêè
#define weekly_close        77    //ñèãíàë íà çàêðûòèå ïîêóïîê è óäàëåíèå íåñðàáîòàâøèõ îðäåðîâ
#define gap_clear           88    //ñèãíàë óäàëåíèÿ íåñðàáîòàâøèõ îðäåðîâ
#define gap_open            99    //ñèãíàë âûñòàâëåíèÿ îðäåðîâ íà ãðàíèöàõ êîðîáêè
//+------------------------------------------------------------------+      
string   comment         = "Master_MM_Droid, v 2.4"; // Êîììåíòàðèé îðäåðîâ
int      error_number = 0;    //êîä îøèáêè
int      rsi_sl = 35;         //ñòîï ëîññ ÒÑ "RSI"
int      ts_step   = 5;       //øàã òðåéëèíãà
//+------------------------------------------------------------------+
int slippage = 5;       //ñëèïåéäæ
int magics[4];          //ìàññèâ ìàãè÷åñêèõ íîìåðîâ
int enter = 6;          // Îòñòóï îò öåíû äëÿ óñòàíîâêè îòëîæåííûõ îðäåðîâ ÒÑ Ïðîðûâ êîðîáêè
int weekly_enter = 15;  // Îòñòóï îò öåíû äëÿ óñòàíîâêè îòëîæåííûõ îðäåðîâ ÒÑ Ëåíèâûé òðåéäåð
int gap_stop = 105;            //ñòîï ëîññ ÒÑ Ãýï ïîíåäåëüíèêà
//-----------------------ôëàãè êðàõà ÒÑ äëÿ ïîäñèñòåìû çàùèòû äåïîçèòà
bool ts_rsi_on = true; 
bool ts_weekly_on = true;
bool ts_gap_on = true; 
bool ts_box_on = true;
//-----------------------
string symbol;
int rebalance_index[] = {0, 0, 0, 0};
//-----------------------ïåðâè÷íàÿ èíèöèàëèçàöèÿ
void init()
{
symbol = Symbol();

      magics[0] = rsi_magic;
      magics[1] = boxes_magic; 
      magics[2] = weekly_magic; 
      magics[3] = gap_magic;
      
 if (Digits == 5 || Digits == 3)
   {
      gap_stop *= 10;
      enter   *= 10;
      slippage *= 10;
      ts_step  *= 10;
      rsi_sl   *= 10; 
      weekly_enter   *= 10; 
      dif    *= 10;
   }

   if (balance_separator == 0)
      {
      balance_separator = 1;
      }
   else
      {
      double t_blnc = balance_separator*AccountBalance();
      rajan_jones_level = t_blnc;
      martingale_balance = t_blnc;
      antimartingale_balance = t_blnc;
      virtual_deposit = t_blnc;
//+------------------------------------------------------------------+      
      start_virtual_balance[0] = t_blnc;
      start_virtual_balance[1] = t_blnc;
      start_virtual_balance[2] = t_blnc;
      start_virtual_balance[3] = t_blnc;
      }
      min_lot = MathMax(NormalizeDouble(virtual_deposit/100000,2), MarketInfo(Symbol(), MODE_MINLOT));
      
   return (0);
}
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{        
info();
         
return(0);
}
//-----------------------çàïóñê ñîâåòíèêà
int start(){
   if (IsTradeAllowed()==false || Volume[0]>1) return (0);
   for(int main_count=0; main_count < 4; main_count++){
   int magic_number = magics[main_count];
      switch(scan_market(symbol, magic_number))
            {
      case sell_signal:
            if (ts_rsi_on == true)
            sell_routine(mm_rsi_mode, symbol, magic_number, rsi_sl);
            break;
      case buy_signal:
            if (ts_rsi_on == true)
            buy_routine(mm_rsi_mode, symbol, magic_number, rsi_sl); 
            break;
      case clear_signal:
            close_all(symbol, magic_number);    
            break;
      case set_stops:
            if (ts_box_on == true)
            set_stop_orders(mm_boxes_mode, symbol, magic_number);
            break;
      case weekly_open: 
            if (ts_weekly_on == true)
            weekly_orders(mm_weekly_mode, symbol, magic_number); 
            break;
      case weekly_close: 
            close_all(symbol, magic_number);    
            break;
      case gap_clear: 
            close_all(symbol, magic_number);
            break;
      case gap_open:
            if (ts_gap_on == true)
            gap_weekly(mm_gap_mode, symbol, magic_number);
            break;
      case no_signal: 
            trailing(symbol, magic_number); 
            break;
      case error_signal: 
            Print(error_func(error_number));
            error_number = 0;
            break;
            }
         }   
return (0);}
//-----------------------ìàêðîôóíêöèÿ òðåéëèíãà
void trailing(string symbol, int mn)
{
   int ts = mn;
   if(Digits == 5 || Digits == 3) ts *= 10;
   
while(!IsTradeAllowed()) Sleep(100);
for (int i=OrdersTotal()-1; i>=0; i--)
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol() == symbol && OrderMagicNumber()==mn) trail_order(OrderTicket(), ts);
return;
}
//-----------------------òðåéëèíã ïîçèöèé
void trail_order(int ticket, int treil_stop)
{ 
 if(OrderType()==OP_BUY && Bid-treil_stop*Point>OrderStopLoss()+ts_step*Point) 
 trail_routine(OrderTicket(), NormalizeDouble(Bid-treil_stop*Point,Digits));
 if(OrderType()==OP_SELL && Ask+treil_stop*Point<OrderStopLoss()-ts_step*Point) 
 trail_routine(OrderTicket(), NormalizeDouble(Ask+treil_stop*Point,Digits));
}
//-----------------------ðóòèíà òðåéëèíãà
void trail_routine(int ticket, double price)
{
int count = 0; 
 if(OrderSelect(ticket,SELECT_BY_TICKET))     
     while(OrderModify(ticket,OrderOpenPrice(),price,0,0,CLR_NONE) == false)
     {
     Sleep(30000); RefreshRates();count++; 
     if(count > 5) break;
     }  
return;
}
//-----------------------çàêðûòèå ïðîäàæ 
void close_all(string symbol, int mn){

for(int i=OrdersTotal()-1;i>=0;i--)
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) && OrderSymbol() == symbol && OrderMagicNumber()==mn) close_order(OrderTicket());
return;
}
//+------------------------------------------------------------------+
//Ðóòèíà äëÿ çàêðûòèÿ îðäåðà
void close_order(int ticket)
{
double price = 0;
bool temp = false;
int count = 0;
 while(!IsTradeAllowed()) Sleep(100);
 if(OrderType()==OP_BUY)  price = NormalizeDouble(Bid,Digits);
 if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits);
 if(OrderSelect(ticket,SELECT_BY_TICKET))
     while(temp == false)
     {
     if(OrderType()==OP_BUYSTOP || OrderType()==OP_SELLSTOP) temp = OrderDelete(ticket); 
     else temp = OrderClose(ticket,OrderLots(),price,slippage,CLR_NONE);
     Sleep(30000); RefreshRates();count++; 
     if(count > 5) break;
     }  
return;
}
//-----------------------ïîäñ÷åò ïîçèöèé
int calculate_orders(string symbol, int cmd, int mn) 
{
   int count = 0;
   for(int trade = OrdersTotal() - 1; trade >= 0; trade--) 
   {
      OrderSelect(trade, SELECT_BY_POS, MODE_TRADES);
      if(OrderSymbol() == symbol && OrderMagicNumber() == mn && OrderType() == cmd) count++;
   }
   return (count);
}
//-----------------------ïîèñê ñèãíàëîâ
int scan_market(string symbol, int magic){
error_number = GetLastError();
   if(error_number!=0) return (error_signal);   
    int b_orders = calculate_orders(symbol, OP_BUY, magic);
    int s_orders = calculate_orders(symbol, OP_SELL, magic);
    //int t_orders = trade_orders(symbol, magic);
    int t_orders = s_orders + b_orders;
    int st_orders = stop_orders(symbol, magic);
 
switch(magic){
case rsi_magic:
//-----------------------          
     double open_price = 0;
     double r1 = iRSI(NULL,0,14,PRICE_CLOSE,1);
     double r2 = iRSI(NULL,0,14,PRICE_CLOSE,2);
//-----------------------          
     for(int t = 0; t < OrdersTotal(); t++) 
      {
      OrderSelect(t, SELECT_BY_POS, MODE_TRADES);
      if(OrderSymbol() == symbol && OrderMagicNumber() == rsi_magic)
      open_price = OrderOpenPrice();
      }
//-----------------------êðèòåðèè ïîêóïêè      
     if((r2 < 30 && r1 > 30 && b_orders == 0) || (b_orders > 0 && b_orders < orders_limit && Bid > open_price + dif*Point))
      return (buy_signal);  
//-----------------------êðèòåðèè ïðîäàæè      
     if((r2 > 70 && r1 < 70 && s_orders == 0) || (s_orders > 0 && s_orders < orders_limit && Ask < open_price - dif*Point))
      return (sell_signal);  
      break;
case boxes_magic:
//-----------------------êðèòåðèè    
   if(TimeHour(TimeCurrent()) == (0 + time_shift) || 
   TimeHour(TimeCurrent()) == (10 + time_shift) || 
   TimeHour(TimeCurrent()) == (16 + time_shift))
      return (clear_signal);      
   if((TimeHour(TimeCurrent()) == (6 + time_shift) || 
   TimeHour(TimeCurrent()) == (12 + time_shift) || 
    TimeHour(TimeCurrent()) == (20 + time_shift)) && st_orders == 0)
      return (set_stops);                 
//-----------------------      
      break;
case weekly_magic:
//-----------------------êðèòåðèè          
            if(DayOfWeek() == 1 && Hour() > (start_hour + time_shift) && Hour() < (6 + time_shift) && t_orders == 0 && st_orders == 0)
            //if (DayOfWeek() == 1 && Hour() > start_hour && Hour() < 8 && t_orders == 0 && st_orders == 0)
            return (weekly_open);
            if(DayOfWeek() == 5 && Hour() > (18 + time_shift) && t_orders >= 0) //&& stop_orders(symbol, magic) == 1)
            //if (DayOfWeek() == 5 && Hour() > 20 && t_orders >= 0) //&& stop_orders(symbol, magic) == 1)
            return(weekly_close);  
            break;            
//-----------------------êðèòåðèè          
case gap_magic:      
            if(OrderSelect (0, SELECT_BY_POS) && iBarShift (symbol, PERIOD_D1, OrderOpenTime ()) >= 1)
            return (gap_clear);
            if(t_orders == 0 && Hour () == 0)
            return(gap_open);
            break;     
}
return (no_signal);}
//---------------------------------------------------------------------------------------------------------
int stop_orders(string symbol, int mn)
{
   return(calculate_orders(symbol,OP_SELLSTOP, mn) + calculate_orders(symbol, OP_BUYSTOP, mn)); 
}
//---------------------------------------------------------------------------------------------------------
/*int trade_orders(string symbol, int mn)
{
   return (calculate_orders(symbol,OP_SELL, mn) + calculate_orders(symbol, OP_BUY, mn)); 
}*/
//-----------------------ïîêóïêà, âîçâðàùàåò òèêåò
int gap_weekly(int mm, string symbol, int magic)
  {
  while(!IsTradeAllowed()) Sleep(100);
   double buy_sl  = NormalizeDouble(Ask-gap_stop*Point, Digits);
   double sell_sl = NormalizeDouble(Bid+gap_stop*Point, Digits);
   int stop = (buy_sl - sell_sl)/Point;
         int count = 0;
         double lot = mm_func(mm, symbol, magic, stop);
         if(lot == 0){
         Print("ÒÑ Íåäåëüíûé ãýï îòêëþ÷åíà èç-çà ñëèâà");
         ts_gap_on = false;
         return (0);         
         }
         
         if(iOpen (symbol, PERIOD_D1, 0) < iLow (symbol, PERIOD_D1, 1))
         {
         while(OrderSend (symbol, OP_BUY, lot, Ask, slippage, buy_sl, 0, comment, magic , 0, CLR_NONE) < 0)
         {
         Sleep(30000); RefreshRates(); count++; if(count > 10) break;}
         count = 0;
         }
         else
         if(iOpen (symbol, PERIOD_D1, 0) > iHigh (symbol, PERIOD_D1, 1))
         {
         while(OrderSend (symbol, OP_SELL, lot, Bid, slippage, sell_sl, 0, comment, magic, 0, CLR_NONE) < 0)
         {
         Sleep(30000); RefreshRates(); count++; if(count > 10) break;}
         count = 0;
         }
   return(0);
  }
//-----------------------ïîêóïêà, âîçâðàùàåò òèêåò
int weekly_orders(int mm, string symbol, int magic)
{      
      while(!IsTradeAllowed()) Sleep(100);
      double high = iHigh(symbol,PERIOD_M5,
      iHighest(symbol,PERIOD_M5,MODE_HIGH, (start_hour + time_shift)*16, 0));
      //iHighest(symbol,PERIOD_M5,MODE_HIGH, start_hour*16, 0));
      double low = iLow(symbol,PERIOD_M5, 
      iLowest(symbol,PERIOD_M5,MODE_LOW, (start_hour + time_shift)*16, 0));
      //iLowest(symbol,PERIOD_M5,MODE_LOW, start_hour*16, 0));
      double buy  = NormalizeDouble(high + weekly_enter*Point, Digits);
      double sell = NormalizeDouble(low - weekly_enter*Point, Digits);
      int stop = (buy - sell)/Point;
      int count = 0;
      double lot = mm_func(mm, symbol, magic, stop);
      if(lot == 0){
         Print("ÒÑ Ëåíèâûé òðåéäåð îòêëþ÷åíà èç-çà ñëèâà");
         ts_weekly_on = false;
         return (0);         
         }
      while(OrderSend(symbol, OP_BUYSTOP,  lot, buy,  slippage, sell , 0,  comment, magic, 0, CLR_NONE) < 0)
           {Sleep(30000); RefreshRates(); count++; if(count > 10) break;}
      count = 0;
      while(OrderSend(symbol, OP_SELLSTOP, lot, sell, slippage, buy ,0, comment, magic, 0, CLR_NONE) < 0)
           {Sleep(30000); RefreshRates(); count++; if(count > 10) break;}      
return (0);
         }
//-----------------------ïîêóïêà
int set_stop_orders(int mm, string symbol, int magic)
{
      while(!IsTradeAllowed()) Sleep(100);
      double high = iHigh(symbol, PERIOD_H1, 1);
      double low  = iLow(symbol, PERIOD_H1, 1);
      
      //double buy  = high + enter*Point;
      //double sell = low - enter*Point;
      double buy  = NormalizeDouble(high + enter*Point, Digits);
      double sell = NormalizeDouble(low - enter*Point, Digits);
      int stop = (buy - sell)/Point;
      double lot = mm_func(mm, symbol, magic, stop);
     if(lot == 0){
         Print("ÒÑ Ïðîðûâ êîðîáêè îòêëþ÷åíà èç-çà ñëèâà");
         ts_box_on = false; 
         return (0);         
         }
      int count = 0;
     while(OrderSend(symbol, OP_BUYSTOP, lot, buy,  slippage, sell, 0, comment, magic , 0, CLR_NONE) < 0)
           {Sleep(30000); RefreshRates(); count++; if(count > 5) break;}
     
      count = 0;
     while(OrderSend(symbol, OP_SELLSTOP, lot, sell, slippage, buy, 0, comment, magic , 0, CLR_NONE) < 0)
           {Sleep(30000); RefreshRates(); count++; if(count > 5) break;}
           
return (0);
}//-----------------------ïîêóïêà, âîçâðàùàåò òèêåò
int buy_routine(int mm, string symbol, int magic, int sl)
{
     while(!IsTradeAllowed()) Sleep(100);
     int count = 0;
     int i = -1;
     double lot = mm_func(mm, symbol, magic, 35);
     if(lot == 0){
         Print("ÒÑ RSI îòêëþ÷åíà èç-çà ñëèâà");
         ts_rsi_on = false;
         return (0);         
         }
     while(i < 0)
     {
     i = OrderSend(symbol,OP_BUY,lot,Ask,slippage,Ask-sl*Point,0,comment,magic,0,CLR_NONE);
     Sleep(30000); RefreshRates();count++;
     if(count > 5) break;
     } 
return (i);
}
//-----------------------ïðîäàæà, âîçâðàùàåò òèêåò
int sell_routine(int mm, string symbol, int magic, int sl)
{
     while(!IsTradeAllowed()) Sleep(100);
     int count = 0;
     int i = -1;
     double lot = mm_func(mm, symbol, magic, 35);
     if(lot == 0){
         Print("ÒÑ RSI îòêëþ÷åíà èç-çà ñëèâà");
         ts_rsi_on = false;
         return (0);         
         }
     while(i < 0)
     {
     i = OrderSend(symbol,OP_SELL,lot,Bid,slippage,Bid+sl*Point,0,comment,magic,0,CLR_NONE);
     Sleep(30000); RefreshRates();count++; 
     if(count > 5) break;
     } 
 
return (i);
}
//+------------------------------------------------------------------+
// MM
//+------------------------------------------------------------------+
double mm_func(int mm_mode, string symbol, int mn, int stop)
{
//+------------------------------------------------------------------+
double lot = 0; 
rebalance(get_balance(mn));
//+------------------------------------------------------------------+
   if(Digits == 5 || Digits == 3)
               {
               stop *= 10;
               }
//--------------------------------------- Ðåáàëàíñèðîâêà êàïèòàëà, ïåðåðàñïðåäåëåíèå ïðèáûëè 
virtual_deposit = virtual_balance(symbol, mn, get_rebalance_index(mn));   
//--------------------------------------- 
   switch(mm_mode)
   {
      case mm_math_sqrt: //1
               lot = math_sqrt(virtual_deposit);
               break;
      case mm_percent:  //2
               lot = percent(virtual_deposit);
               break;         
      case mm_martingale: //3
               lot = martingale(virtual_deposit);
               break;          
      case mm_antimartingale: //4
               lot = antimartingale(virtual_deposit);
               break;
      case mm_rajan_jones: //5
               lot = rajan_jones(virtual_deposit, mn);
               break;
      case mm_larry_williams: //6     
               lot = larry_williams(virtual_deposit, 5);
               break;    
      case mm_second_chance: //7
               lot = min_lot;
               break;
      case mm_f2stop: //8 
               lot = quasi_lots(symbol, stop, risk, virtual_deposit);
               break;   
      case mm_test: //9
               //lot = virtual_deposit / ((stop*MarketInfo(symbol, MODE_TICKVALUE)) / risk);
               lot = crazy(virtual_deposit);
               break;   
      default: lot = 0.1;  
               break;   
            }
//+------------------------------------------------------------------+
         double lot_step = MarketInfo(symbol, MODE_LOTSTEP);
         lot = MathRound(lot / lot_step) * lot_step;  
//+------------------------------------------------------------------+
         lot = MathMin(MathMax(lot, min_lot),MarketInfo(symbol,MODE_MAXLOT));
         Comment(" Çàïðîñ ê ðåæèìó ÌÌ ", mm_names[mm_mode], "\n Ñèìâîë çàïðîñà: ", symbol, " \n ", ts_name(mn), 
         "  \n Âèðòóàëüíûé äåïîçèò: ", virtual_deposit, " \n Ðåàëüíûé áàëàíñ: ", AccountBalance(), 
         " \n Çàïðîøåííûé ëîò: ", NormalizeDouble(lot, 2));   
//+------------------------------------------------------------------+
         double safe_level = virtual_deposit - margin_to_lot(symbol, lot);
         if(safe_level > 0)
            {
         return(NormalizeDouble(lot, 2));
            }
//+------------------------------------------------------------------+
         else if(safe_level <= 0)
            {
         return(second_chance(symbol, lot, virtual_deposit, mm_mode, mn));
            }
//+------------------------------------------------------------------+
}         
//+------------------------------------------------------------------+         
double second_chance(string symbol, double lot, double deposit, int mm, int mn)
{
//+------------------------------------------------------------------+
         Print(" Íå õâàòàåò âèðòóàëüíîé ìàðæè, ðåæèì ÌÌ: (", mm_names[mm], "), ñèìâîë: ", symbol);
         Print(" Òðåáóåìàÿ âèðòóàëüíàÿ ìàðæà äëÿ çàïðîøåííîãî ëîòà: ", margin_to_lot(symbol, lot));
         Print(" Çàïðîøåííûé ëîò: ", lot);
         Print(" Îñòàòîê âèðòóàëüíîãî äåïîçèòà: ", deposit);
//+------------------------------------------------------------------+         
         double temp = AccountBalance() - min_lot*400;
//+------------------------------------------------------------------+
         if(temp <= 0 || mm == mm_second_chance)
                     {
                  Print(" ÌÌ ïîëíîñòüþ îòêëþ÷åí, ÒÑ: ", ts_name(mn)," ñëèëà âèðòóàëüíûé äåïîçèò: ", deposit);
                  return(0);
                     }
//+------------------------------------------------------------------+
         else if (temp >= 0 && mm != mm_second_chance)
               {
            //start_virtual_balance += margin_to_lot(symbol, MarketInfo(Symbol(), MODE_MINLOT)*3);
            deposit += MathAbs(deposit)+ margin_to_lot(symbol, min_lot*50);
//+------------------------------------------------------------------+
            Print(" Âêëþ÷åí ðåæèì ïîñëåäíåãî øàíñà, óâåëè÷åí äåïîçèò íà 50 ìèíèìàëüíûõ ëîòîâ: ", deposit);
//+------------------------------------------------------------------+                        
      switch (mn)
         {
      case 35:
      //"ÒÑ Ïðîðûâ êîðîáêè";
      mm_boxes_mode = mm_second_chance;
      break;
      case 50:
      //"ÒÑ RSI";
      mm_rsi_mode = mm_second_chance;
      break;
      case 100:
      //"ÒÑ Ëåíèâûé òðåéäåð";
      mm_weekly_mode = mm_second_chance;
      break;
      case 115:
      //"ÒÑ Ãýï ïîíåäåëüíèêà";
      mm_gap_mode = mm_second_chance;      
      break;
         }
//+------------------------------------------------------------------+
            Print(" Òåêóùàÿ ÒÑ: ", ts_name(mn), " Ïåðåêëþ÷åí ðåæèì ÌÌ íà: ", mm_names[mm_second_chance]);
            return(min_lot);
               }
//+------------------------------------------------------------------+
      return(0);
}
//+------------------------------------------------------------------+
double get_balance(int mn)
{
      switch (mn)
         {
      case 35:
      //"ÒÑ Ïðîðûâ êîðîáêè";
      return (start_virtual_balance[0]);
      break;
      case 50:
      //"ÒÑ RSI";
      return (start_virtual_balance[1]);
      break;
      case 100:
      //"ÒÑ Ëåíèâûé òðåéäåð";
      return (start_virtual_balance[2]);
      break;
      case 115:
      //"ÒÑ Ãýï ïîíåäåëüíèêà";
      return (start_virtual_balance[3]);
      break;
         }
}
//+------------------------------------------------------------------+
void set_balance(int mn, double balance)
{
      switch (mn)
         {
      case 35:
      //"ÒÑ Ïðîðûâ êîðîáêè";
      start_virtual_balance[0] = balance;
      break;
      case 50:
      //"ÒÑ RSI";
      start_virtual_balance[1] = balance;
      break;
      case 100:
      //"ÒÑ Ëåíèâûé òðåéäåð";
      start_virtual_balance[2] = balance;
      break;
      case 115:
      //"ÒÑ Ãýï ïîíåäåëüíèêà";
      start_virtual_balance[3] = balance;
      break;
         }
}
//+------------------------------------------------------------------+
int get_rebalance_index(int mn)
{
      switch (mn)
         {
      case 35:
      //"ÒÑ Ïðîðûâ êîðîáêè";
      return (rebalance_index[0]);
      break;
      case 50:
      //"ÒÑ RSI";
      return (rebalance_index[1]);
      break;
      case 100:
      //"ÒÑ Ëåíèâûé òðåéäåð";
      return (rebalance_index[2]);
      break;
      case 115:
      //"ÒÑ Ãýï ïîíåäåëüíèêà";
      return (rebalance_index[3]);
      break;
         }
}
//+------------------------------------------------------------------+
void set_rebalance_index(int mn, int s)
{
      switch (mn)
         {
      case 35:
      //"ÒÑ Ïðîðûâ êîðîáêè";
      rebalance_index[0] = s;
      break;
      case 50:
      //"ÒÑ RSI";
      rebalance_index[1] = s;
      break;
      case 100:
      //"ÒÑ Ëåíèâûé òðåéäåð";
      rebalance_index[2] = s;
      break;
      case 115:
      //"ÒÑ Ãýï ïîíåäåëüíèêà";
      rebalance_index[3] = s;
      break;
         }
}
//+------------------------------------------------------------------+
double virtual_balance(string symbol, int mn, int seek = 0)
{
double balance = get_balance(mn);
//---------------------------------------
   {
    for (int k = seek; k < OrdersHistoryTotal(); k++)
       {
      OrderSelect (k, SELECT_BY_POS, MODE_HISTORY);
      if(OrderMagicNumber() != mn || OrderSymbol() != symbol) continue;      
      balance += OrderProfit();
       }
   }
return (balance);
}
//+------------------------------------------------------------------+
int count_history(string symbol, int mn)
{
    int t = 0;
    for (int k = 0; k < OrdersHistoryTotal(); k++)
       {
      OrderSelect (k, SELECT_BY_POS, MODE_HISTORY);
      if(OrderMagicNumber() != mn || OrderSymbol() != symbol) continue;      
      t++;
        }
return (t+1);
}
//+------------------------------------------------------------------+
string ts_name(int mn)
{
 string name;
      switch (mn)
         {
      case 35:
      name = " ÒÑ Ïðîðûâ êîðîáêè";
      break;
      case 50:
      name = " ÒÑ RSI";
      break;
      case 100:
      name = " ÒÑ Ëåíèâûé òðåéäåð";
      break;
      case 115:
      name = " ÒÑ Ãýï ïîíåäåëüíèêà";
      break;
         }
return (name);
}
//+------------------------------------------------------------------+
double margin_to_lot(string symbol,double lot_to_check)
{
  return (NormalizeDouble(lot_to_check * MarketInfo(symbol,MODE_MARGINREQUIRED),2));
}
//--------------------------------------- 
double math_sqrt(double deposit)
{
 double lot = 0.2 * MathSqrt(deposit/1000); 
 return (lot);               
}               
//--------------------------------------- 
double percent(double deposit)
{
 double lot = virtual_deposit*risk/MarketInfo(Symbol(),MODE_MARGINREQUIRED);// òîæå ñàìîå   
  return (lot);               
}               
//--------------------------------------- 
double crazy(double deposit)
  {
   double lot, lastprofit=0,lp1=0,lp2=0;
 
   for(int i=0;i<OrdersHistoryTotal() ;i++)
   {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false)  break;
      lp2=lp1;
      lp1=lastprofit;
      lastprofit=OrderProfit();
   }
   lot=NormalizeDouble(AccountFreeMargin()*risk/1000.0,1);
   if (lastprofit<0 && lp1<0 && lp2<0 ) return(lot);
   return(min_lot);
  }
//--------------------------------------- 
double quasi_lots(string symbol, int stop, double ts_risk, double deposit)
{     
double bet = deposit*ts_risk;
//double pip_price = NormalizeDouble(bet/stop,2);
//double contract_size = NormalizeDouble((pip_price / MarketInfo(symbol, MODE_POINT)/100000),2);
 
double step =MarketInfo(Symbol(),MODE_LOTSTEP);
double stop_value = stop * MarketInfo(Symbol(),MODE_TICKVALUE);
double contract_size = NormalizeDouble(bet/stop_value,2);
contract_size = MathFloor(contract_size/step)*step;
return(contract_size);
}
 
//+------------------------------------------------------------------+
double antimartingale(double deposit)
{
 double lot;
               if(antimartingale_balance > deposit)
               { 
               antimartingale_count --;
               }
               if(antimartingale_balance <=deposit)
               { 
               antimartingale_count ++;
               }     
               lot = antimartingale_count * min_lot;
               antimartingale_balance = deposit;
  return (lot);               
}               
//--------------------------------------- 
double martingale(double deposit)
{
 double lot;
               if (martingale_balance <= deposit)
                     { 
               martingale_count = 1; //min_lot = NormalizeDouble(virtual_deposit/100000,2);
                     }
               if (martingale_balance > deposit)
                     { 
               martingale_count +=martingale_count;
                     }
               lot = martingale_count * min_lot;
               martingale_balance = deposit;
  return (lot);               
}               
//--------------------------------------- rajan_jones ---------------------------------
double rajan_jones(double deposit, int mn)
{
double lot;
//[(÷èñëî êîíòðàêòîâ õ ÷èñëî êîíòðàêòîâ - ÷èñëî êîíòðàêòîâ)/2] õ äåëüòà = ìèíèìàëüíûé óðîâåíü ïðèáûëè
               while (rajan_jones_level > deposit && rajan_jones_count >= 1)
                  {
               rajan_jones_count --;
               //if (rajan_jones_count <= 1) {rajan_jones_level = start_virtual_balance; lot = min_lot; break;}
               if (rajan_jones_count <= 1) {rajan_jones_level = get_balance(mn); lot = min_lot; break;}
               rajan_jones_level = (((rajan_jones_count * rajan_jones_count - rajan_jones_count)/2) * delta);
                  }
                  
               while (deposit - rajan_jones_level > delta)
                  {
               rajan_jones_count ++;
               rajan_jones_level = (((rajan_jones_count * rajan_jones_count - rajan_jones_count)/2) * delta);
                  }
                  
               lot = min_lot * rajan_jones_count;
   return (lot);
}
//--------------------------------------- LarryWilliams ---------------------------------
double larry_williams(double deposit, double  risk)
{
   return (deposit * (risk / 100) / deposit);
}
//--------------------------------------- Ðåáàëàíñèðîâêà êàïèòàëà, ïåðåðàñïðåäåëåíèå ïðèáûëè 
void rebalance(double balance)
{
   if(NormalizeDouble(virtual_deposit/balance, 0) > 3)
   {
   for (int i = 0; i < 4; i++)
      {
   set_rebalance_index(magics[i], count_history(symbol, magics[i]));
   set_balance(magics[i], balance_separator*AccountBalance());
      }
   }
}
//-----------------------
int get_mm_name(int mn)
{
      switch (mn)
         {
      case 35:
      //" ÒÑ Ïðîðûâ êîðîáêè";
      return (mm_boxes_mode);
      break;
      case 50:
      //" ÒÑ RSI";
      return (mm_rsi_mode);
      break;
      case 100:
      //" ÒÑ Ëåíèâûé òðåéäåð";
      return (mm_weekly_mode);
      break;
      case 115:
      //" ÒÑ Ãýï ïîíåäåëüíèêà";
      return (mm_gap_mode);
      break;
         }
}
//-----------------------
int info()
{        
         Print(" ðåàëüíûé äåïîçèò: ", AccountBalance());
         for(int i = 0; i < 4; i ++)
         {
         int temp = magics[i];
         Print(ts_name(temp) ,", âèðòóàëüíûé äåïîçèò: ", 
         NormalizeDouble(virtual_balance(symbol, temp, get_rebalance_index(temp)),2),
         " èíäåêñ: ", get_rebalance_index(temp),
         " ðåæèì ÌÌ: ", mm_names[get_mm_name(temp)]);
         }
return(0);
}
//-----------------------îáðàáîò÷èê îøèáîê   
string error_func(int error){
switch(error) {
            case(0):   return("Íåò îøèáêè");
            case(1):   return("Íåò îøèáêè, íî ðåçóëüòàò íåèçâåñòåí");
            case(2):   return("Îáùàÿ îøèáêà");
            case(3):   return("Íåïðàâèëüíûå ïàðàìåòðû");
            case(4):   return("Òîðãîâûé ñåðâåð çàíÿò");
            case(5):   return("Ñòàðàÿ âåðñèÿ êëèåíòñêîãî òåðìèíàëà");
            case(6):   return("Íåò ñâÿçè ñ òîðãîâûì ñåðâåðîì");
            case(7):   return("Íåäîñòàòî÷íî ïðàâ");
            case(8):   return("Ñëèøêîì ÷àñòûå çàïðîñû");
            case(9):   return("Íåäîïóñòèìàÿ îïåðàöèÿ, íàðóøàþùàÿ ôóíêöèîíèðîâàíèå ñåðâåðà");
            case(64):  return("Ñ÷åò çàáëîêèðîâàí");
            case(65):  return("Íåïðàâèëüíûé íîìåð ñ÷åòà");
            case(128): return("Èñòåê ñðîê îæèäàíèÿ ñîâåðøåíèÿ ñäåëêè");
            case(129): return("Íåïðàâèëüíàÿ öåíà");
            case(130): return("Íåïðàâèëüíûå ñòîïû");
            case(131): return("Íåïðàâèëüíûé îáú¸ì");
            case(132): return("Ðûíîê çàêðûò");
            case(133): return("Òîðãîâëÿ çàïðåùåíà");
            case(134): return("Íåäîñòàòî÷íî äåíåã äëÿ ñîâåðøåíèÿ îïåðàöèè");
            case(135): return("Öåíà èçìåíèëàñü");
            case(136): return("Íåò öåí");
            case(137): return("Áðîêåð çàíÿò");
            case(138): return("Íîâûå öåíû");
            case(139): return("Îðäåð çàáëîêèðîâàí è óæå îáðàáàòûâàåòñÿ");
            case(140): return("Ðàçðåøåíà òîëüêî ïîêóïêà");
            case(141): return("Ñëèøêîì ìíîãî çàïðîñîâ");
            case(145): return("Ìîäèôèêàöèÿ çàïðåùåíà, ò.ê. îðäåð ñëèøêîì áëèçîê ê ðûíêó");
            case(146): return("Ïîäñèñòåìà òîðãîâëè çàíÿòà");
            case(147): return("Èñïîëüçîâàíèå äàòû èñòå÷åíèÿ çàïðåùåíî áðîêåðîì");
            case(148): return("Êîëè÷åñòâî îòêðûòûõ è îòëîæåííûõ îðäåðîâ äîñòèãëî ïðåäåëà, óñòàíîâëåííîãî áðîêåðîì");
            case(149): return("Ïîïûòêà îòêðûòü ïðîòèâîïîëîæíóþ ïîçèöèþ ê óæå ñóùåñòâóþùåé â ñëó÷àå, åñëè õåäæèðîâàíèå çàïðåùåíî");
            case(150): return("Ïîïûòêà çàêðûòü ïîçèöèþ ïî èíñòðóìåíòó â ïðîòèâîðå÷èè ñ ïðàâèëîì FIFO");
            case(4000): return("    Íåò îøèáêè");
            case(4001): return("    Íåïðàâèëüíûé óêàçàòåëü ôóíêöèè");
            case(4002): return("Èíäåêñ ìàññèâà - âíå äèàïàçîíà");
            case(4003): return("Íåò ïàìÿòè äëÿ ñòåêà ôóíêöèé");
            case(4004): return("Ïåðåïîëíåíèå ñòåêà ïîñëå ðåêóðñèâíîãî âûçîâà");
            case(4005): return("Íà ñòåêå íåò ïàìÿòè äëÿ ïåðåäà÷è ïàðàìåòðîâ");
            case(4006): return("Íåò ïàìÿòè äëÿ ñòðîêîâîãî ïàðàìåòðà");
            case(4007): return("Íåò ïàìÿòè äëÿ âðåìåííîé ñòðîêè");
            case(4008): return("Íåèíèöèàëèçèðîâàííàÿ ñòðîêà");
            case(4009): return("Íåèíèöèàëèçèðîâàííàÿ ñòðîêà â ìàññèâå");
            case(4010): return("Íåò ïàìÿòè äëÿ ñòðîêîâîãî ìàññèâà");
            case(4011): return("Ñëèøêîì äëèííàÿ ñòðîêà");
            case(4012): return("Îñòàòîê îò äåëåíèÿ íà íîëü");
            case(4013): return("Äåëåíèå íà íîëü");
            case(4014): return("Íåèçâåñòíàÿ êîìàíäà");
            case(4015): return("Íåïðàâèëüíûé ïåðåõîä");
            case(4016): return("Íåèíèöèàëèçèðîâàííûé ìàññèâ");
            case(4017): return("Âûçîâû DLL íå ðàçðåøåíû");
            case(4018): return("Íåâîçìîæíî çàãðóçèòü áèáëèîòåêó");
            case(4019): return("Íåâîçìîæíî âûçâàòü ôóíêöèþ");
            case(4020): return("Âûçîâû âíåøíèõ áèáëèîòå÷íûõ ôóíêöèé íå ðàçðåøåíû");
            case(4021): return("Íåäîñòàòî÷íî ïàìÿòè äëÿ ñòðîêè, âîçâðàùàåìîé èç ôóíêöèè");
            case(4022): return("Ñèñòåìà çàíÿòà");
            case(4050): return("Íåïðàâèëüíîå êîëè÷åñòâî ïàðàìåòðîâ ôóíêöèè");
            case(4051): return("Íåäîïóñòèìîå çíà÷åíèå ïàðàìåòðà ôóíêöèè");
            case(4052): return("Âíóòðåííÿÿ îøèáêà ñòðîêîâîé ôóíêöèè");
            case(4053): return("Îøèáêà ìàññèâà");
            case(4054): return("Íåïðàâèëüíîå èñïîëüçîâàíèå ìàññèâà-òàéìñåðèè");
            case(4055): return("Îøèáêà ïîëüçîâàòåëüñêîãî èíäèêàòîðà");
            case(4056): return("Ìàññèâû íåñîâìåñòèìû");
            case(4057): return("Îøèáêà îáðàáîòêè ãëîáàëüíûåõ ïåðåìåííûõ");
            case(4058): return("Ãëîáàëüíàÿ ïåðåìåííàÿ íå îáíàðóæåíà");
            case(4059): return("Ôóíêöèÿ íå ðàçðåøåíà â òåñòîâîì ðåæèìå");
            case(4060): return("Ôóíêöèÿ íå ðàçðåøåíà");
            case(4061): return("Îøèáêà îòïðàâêè ïî÷òû");
            case(4062): return("Îæèäàåòñÿ ïàðàìåòð òèïà string");
            case(4063): return("Îæèäàåòñÿ ïàðàìåòð òèïà integer");
            case(4064): return("Îæèäàåòñÿ ïàðàìåòð òèïà double");
            case(4065): return(" êà÷åñòâå ïàðàìåòðà îæèäàåòñÿ ìàññèâ");
            case(4066): return("Çàïðîøåííûå èñòîðè÷åñêèå äàííûå â ñîñòîÿíèè îáíîâëåíèÿ");
            case(4067): return("Îøèáêà ïðè âûïîëíåíèè òîðãîâîé îïåðàöèè");
            case(4099): return("Êîíåö ôàéëà");
            case(4100): return("Îøèáêà ïðè ðàáîòå ñ ôàéëîì");
            case(4101): return("Íåïðàâèëüíîå èìÿ ôàéëà");
            case(4102): return("Ñëèøêîì ìíîãî îòêðûòûõ ôàéëîâ");
            case(4103): return("Íåâîçìîæíî îòêðûòü ôàéë");
            case(4104): return("Íåñîâìåñòèìûé ðåæèì äîñòóïà ê ôàéëó");
            case(4105): return("Íè îäèí îðäåð íå âûáðàí");
            case(4106): return("Íåèçâåñòíûé ñèìâîë");
            case(4107): return("Íåïðàâèëüíûé ïàðàìåòð öåíû äëÿ òîðãîâîé ôóíêöèè");
            case(4108): return("Íåâåðíûé íîìåð òèêåòà");
            case(4109): return("Òîðãîâëÿ íå ðàçðåøåíà. Íåîáõîäèìî âêëþ÷èòü îïöèþ -*- Ðàçðåøèòü ñîâåòíèêó òîðãîâàòü -*- â ñâîéñòâàõ ýêñïåðòà.");
            case(4110): return("Äëèííûå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà.");
            case(4111): return("Êîðîòêèå ïîçèöèè íå ðàçðåøåíû. Íåîáõîäèìî ïðîâåðèòü ñâîéñòâà ýêñïåðòà.");
            case(4200): return("Îáúåêò óæå ñóùåñòâóåò");
            case(4201): return("Çàïðîøåíî íåèçâåñòíîå ñâîéñòâî îáúåêòà");
            case(4202): return("Îáúåêò íå ñóùåñòâóåò");
            case(4203): return("Íåèçâåñòíûé òèï îáúåêòà");
            case(4204): return("Íåò èìåíè îáúåêòà");
            case(4205): return("Îøèáêà êîîðäèíàò îáúåêòà");
            case(4206): return("Íå íàéäåíî óêàçàííîå ïîäîêíî");
            case(4207): return("Îøèáêà ïðè ðàáîòå ñ îáúåêòîì");
            default:   return("Íåðàñïîçíàííàÿ îøèáêà"); 
   } 
}