//+------------------------------------------------------------------+
//|                                                                  |
//|                                                       funtik.mq4 |
//|                                        Copyright © 2007, sashken |
//|                                                                  |
//+------------------------------------------------------------------+


#property copyright "Copyright © 2007, sashken, sashken@mail.ru"
#property link      "sashken@mail.ru"


//////////////////////////////////////////////////////////////////////
//                                                                  //
// Предупреждение: данный советник создан специально для Чемпионата //
// (пожалуйста, не используйте на реале!!!)                         //
//                                                                  //
// Please don't use this EA on real money (only Demo or Testing)    //
//                                                                  //
//////////////////////////////////////////////////////////////////////
//                                                                  //
// Используется:                                                    //
// | MACD Sample (сигналы открытия/закрытия)                        //
// | e-TrailingStop (Игорь Ким, KimIV)                              //
//                                                                  //
//////////////////////////////////////////////////////////////////////


///////////////////////////////////////////////////////////////////////

extern double MaximumRisk        = 0.15;
extern int    MaxOrders          = 3;
extern double MaxLots            = 5;

///////////////////////////////////////////////////////////////////////
// использовать(1) / не использовать(0)

extern int    macd__1            = 1;
extern int    macd__2            = 1;
extern int    macd__3            = 1;
extern int    macd__4            = 1;
extern int    macd__5            = 1;
extern int    macd__6            = 1;
extern int    macd__7            = 1;
extern int    macd__8            = 1;
extern int    macd__9            = 1;
extern int    macd__10           = 1;
extern int    macd__11           = 1;
extern int    macd__12           = 1;

///////////////////////////////////////////////////////////////////////
// MACD_1

extern double TakeProfit         = 300;
extern double StopLoss           = 45;
extern double TrailingStop       = 5;
extern double MACDOpenLevel      = 6;
extern double MACDCloseLevel     = 50;
extern double MATrendPeriod      = 11;
extern int    MACDf              = 194;
extern int    MACDs              = 475;
extern int    MACDsig            = 45;

///////////////////////////////////////////////////////////////////////
// MACD_2

extern double TakeProfit_2       = 90;
extern double StopLoss_2         = 175;
extern double TrailingStop_2     = 15;
extern double MACDOpenLevel_2    = 7;
extern double MACDCloseLevel_2   = 83;
extern double MATrendPeriod_2    = 44;
extern int    MACDf_2            = 67;
extern int    MACDs_2            = 316;
extern int    MACDsig_2          = 39;

//////////////////////////////////////////////////////////////////////
// MACD_3

extern double TakeProfit_3       = 95;
extern double StopLoss_3         = 195;
extern double TrailingStop_3     = 100;
extern double MACDOpenLevel_3    = 14;
extern double MACDCloseLevel_3   = 87;
extern double MATrendPeriod_3    = 50;
extern int    MACDf_3            = 10;
extern int    MACDs_3            = 436;
extern int    MACDsig_3          = 28;

//////////////////////////////////////////////////////////////////////
// MACD_4

extern double TakeProfit_4       = 50;
extern double StopLoss_4         = 95;
extern double TrailingStop_4     = 95;
extern double MACDOpenLevel_4    = 54;
extern double MACDCloseLevel_4   = 93;
extern double MATrendPeriod_4    = 65;
extern int    MACDf_4            = 181;
extern int    MACDs_4            = 482;
extern int    MACDsig_4          = 36;

//////////////////////////////////////////////////////////////////////
// MACD_5

extern double TakeProfit_5       = 265;
extern double StopLoss_5         = 185;
extern double TrailingStop_5     = 20;
extern double MACDOpenLevel_5    = 18;
extern double MACDCloseLevel_5   = 24;
extern double MATrendPeriod_5    = 24;
extern int    MACDf_5            = 27;
extern int    MACDs_5            = 459;
extern int    MACDsig_5          = 79;

//////////////////////////////////////////////////////////////////////
// MACD_6

extern double TakeProfit_6       = 80;
extern double StopLoss_6         = 190;
extern double TrailingStop_6     = 70;
extern double MACDOpenLevel_6    = 75;
extern double MACDCloseLevel_6   = 104;
extern double MATrendPeriod_6    = 40;
extern int    MACDf_6            = 3;
extern int    MACDs_6            = 260;
extern int    MACDsig_6          = 40;

//////////////////////////////////////////////////////////////////////
// MACD_7

extern double TakeProfit_7       = 285;
extern double StopLoss_7         = 50;
extern double TrailingStop_7     = 10;
extern double MACDOpenLevel_7    = 102;
extern double MACDCloseLevel_7   = 86;
extern double MATrendPeriod_7    = 69;
extern int    MACDf_7            = 77;
extern int    MACDs_7            = 67;
extern int    MACDsig_7          = 27;

//////////////////////////////////////////////////////////////////////
// MACD_8

extern double TakeProfit_8       = 25;
extern double StopLoss_8         = 145;
extern double TrailingStop_8     = 100;
extern double MACDOpenLevel_8    = 36;
extern double MACDCloseLevel_8   = 136;
extern double MATrendPeriod_8    = 1;
extern int    MACDf_8            = 116;
extern int    MACDs_8            = 430;
extern int    MACDsig_8          = 9;

//////////////////////////////////////////////////////////////////////
// MACD_9

extern double TakeProfit_9       = 75;
extern double StopLoss_9         = 105;
extern double TrailingStop_9     = 35;
extern double MACDOpenLevel_9    = 54;
extern double MACDCloseLevel_9   = 93;
extern double MATrendPeriod_9    = 68;
extern int    MACDf_9            = 181;
extern int    MACDs_9            = 482;
extern int    MACDsig_9          = 36;

//////////////////////////////////////////////////////////////////////
// MACD_10

extern double TakeProfit_10      = 175;
extern double StopLoss_10        = 190;
extern double TrailingStop_10    = 50;
extern double MACDOpenLevel_10   = 44;
extern double MACDCloseLevel_10  = 54;
extern double MATrendPeriod_10   = 55;
extern int    MACDf_10           = 12;
extern int    MACDs_10           = 26;
extern int    MACDsig_10         = 9;

//////////////////////////////////////////////////////////////////////
// MACD_11

extern double TakeProfit_11      = 285;
extern double StopLoss_11        = 200;
extern double TrailingStop_11    = 40;
extern double MACDOpenLevel_11   = 121;
extern double MACDCloseLevel_11  = 64;
extern double MATrendPeriod_11   = 53;
extern int    MACDf_11           = 13;
extern int    MACDs_11           = 435;
extern int    MACDsig_11         = 47;

//////////////////////////////////////////////////////////////////////
// MACD_12

extern double TakeProfit_12      = 75; // 10  // 75
extern double StopLoss_12        = 10; // 10  // 50
extern double TrailingStop_12    = 15; // 80  // 15
extern double MACDOpenLevel_12   = 21; // 13  // 21 // 12
extern double MACDCloseLevel_12  = 39; // 20  // 39 // 18
extern double MATrendPeriod_12   = 89;
extern int    MACDf_12           = 24;
extern int    MACDs_12           = 52;
extern int    MACDsig_12         = 18;

///////////////////////////////////////////////////////////////////////
// Магики

extern int    Magic_1            = 1001001;
extern int    Magic_2            = 1001002;
extern int    Magic_3            = 1001003;
extern int    Magic_4            = 1001004;
extern int    Magic_5            = 1001005;
extern int    Magic_6            = 1001006;
extern int    Magic_7            = 1001007;
extern int    Magic_8            = 1001008;
extern int    Magic_9            = 1001009;
extern int    Magic_10           = 1001010;
extern int    Magic_11           = 1001011;
extern int    Magic_12           = 1001012;

///////////////////////////////////////////////////////////////////////
// Трал

extern bool   ProfitTrailing     = True;  // Тралить только профит
extern int    TrailingStep       = 7;     // Шаг трала

///////////////////////////////////////////////////////////////////////
// Кол-во попыток открытия ордера при реквотах

extern int    raz                = 5;

///////////////////////////////////////////////////////////////////////
// 

double        Lots               = 0.1;
int           slipage            = 3;
int           _prevTime          = 0;


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


int init()
{
	 
}


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


int start()
{
   if (!Trade()) return(0);

   int curTime = Time[0];
   if (_prevTime != curTime)
   {
      newBar();
      _prevTime = curTime;
   }
   newTick();

   return(0);
}



int newTick()
{     
   
   for (int i=0; i<OrdersTotal(); i++)
      {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
         {
         TrailingPositions();
         }
      }
   
   return(0);
}   



int newBar()
{  

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__7==1) exp7()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__8==1) exp8()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__4==1) exp4()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__5==1) exp5()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__6==1) exp6()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__1==1) exp1()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__2==1) exp2()  ;
  
if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__12==1) exp12()  ;
  
if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__3==1) exp3()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__9==1) exp9()  ;

if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__10==1) exp10()  ;
  
if(AccountFreeMargin()<(1000*LotSize()))
   {
   Print("We have no money. Free Margin = ", AccountFreeMargin());
   return(0);  
   }
if (macd__11==1) exp11()  ;
  
  return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp1()
  {
  
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf,MACDs,MACDsig,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_1)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss, TakeProfit, Magic_1);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss, TakeProfit, Magic_1);
        }
      return(0);
     }

   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if (OrderMagicNumber()!=Magic_1) continue;
      else
      {
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())  
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
          }
        }
     }
   return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////




int exp2()
  {

   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_2,MACDs_2,MACDsig_2,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_2,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_2,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_2)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_2*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_2, TakeProfit_2, Magic_2);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_2*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_2, TakeProfit_2, Magic_2);
        }
      return(0);
     }
     
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_2) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_2*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_2*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }
  


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp3()
  {
  
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_3,MACDs_3,MACDsig_3,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_3,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_3,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_3)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_3*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_3, TakeProfit_3, Magic_3);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_3*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_3, TakeProfit_3, Magic_3);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_3) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_3*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_3*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp4()
  {

   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_4,MACDs_4,MACDsig_4,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_4,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_4,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_4)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_4*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_4, TakeProfit_4, Magic_4);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_4*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_4, TakeProfit_4, Magic_4);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_4) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_4*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_4*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp5()
  {

   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_5,MACDs_5,MACDsig_5,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_5,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_5,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_5)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_5*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_5, TakeProfit_5, Magic_5);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_5*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_5, TakeProfit_5, Magic_5);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_5) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_5*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_5*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp6()
  {
  
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,240,MACDf_6,MACDs_6,MACDsig_6,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,240,MATrendPeriod_6,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,240,MATrendPeriod_6,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_6)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_6*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_6, TakeProfit_6, Magic_6);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_6*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_6, TakeProfit_6, Magic_6);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_6) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_6*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_6*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp7()
  {
  
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;

   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }

   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_7,MACDs_7,MACDsig_7,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_7,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_7,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_7)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_7*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_7, TakeProfit_7, Magic_7);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_7*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_7, TakeProfit_7, Magic_7);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_7) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_7*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_7*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp8()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_8,MACDs_8,MACDsig_8,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_8,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_8,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_8)<1 && OrdersTotal()<MaxOrders) 
     {
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_8*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_8, TakeProfit_8, Magic_8);
        }
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_8*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_8, TakeProfit_8, Magic_8);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_8) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_8*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_8*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }
  
  
  
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp9()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_9,MACDs_9,MACDsig_9,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_9,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_9,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_9)<1 && OrdersTotal()<MaxOrders) 
     {
      
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_9*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_9, TakeProfit_9, Magic_9);
        }
      
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_9*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_9, TakeProfit_9, Magic_9);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_9) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_9*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_9*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }
  

  
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp10()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_10,MACDs_10,MACDsig_10,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_10,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_10,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_10)<1 && OrdersTotal()<MaxOrders) 
     {
      
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_10*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_10, TakeProfit_10, Magic_10);
        }
      
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_10*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_10, TakeProfit_10, Magic_10);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_10) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
            
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_10*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
            
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_10*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }
  
  

  
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp11()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_11,MACDs_11,MACDsig_11,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_11,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_11,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_11)<1 && OrdersTotal()<MaxOrders) 
     {
      
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_11*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_11, TakeProfit_11, Magic_11);
        }
      
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_11*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_11, TakeProfit_11, Magic_11);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_11) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
      
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_11*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
      
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_11*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }
  
  
  

  
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int exp12()
  {
   double MacdCurrent, MacdPrevious, SignalCurrent;
   double SignalPrevious, MaCurrent, MaPrevious;
   int cnt, ticket, total;
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
   MacdCurrent    = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_MAIN,1),8);
   MacdPrevious   = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_MAIN,2),8);
   SignalCurrent  = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_SIGNAL,1),8);
   SignalPrevious = NormalizeDouble(iMACD(NULL,0,MACDf_12,MACDs_12,MACDsig_12,PRICE_CLOSE,MODE_SIGNAL,2),8);
   MaCurrent      = NormalizeDouble(iMA(NULL,0,MATrendPeriod_12,0,MODE_EMA,PRICE_CLOSE,1),8);
   MaPrevious     = NormalizeDouble(iMA(NULL,0,MATrendPeriod_12,0,MODE_EMA,PRICE_CLOSE,2),8);

   if(OrderTotalMagic(Magic_12)<1 && OrdersTotal()<MaxOrders) 
     {
      
      if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
         MathAbs(MacdCurrent)>(MACDOpenLevel_12*Point) && MaCurrent>MaPrevious)
        {
         OpenBuy(StopLoss_12, TakeProfit_12, Magic_12);
        }
      
      if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious && 
         MacdCurrent>(MACDOpenLevel_12*Point) && MaCurrent<MaPrevious)
        {
         OpenSell(StopLoss_12, TakeProfit_12, Magic_12);
        }
      return(0);
     }
   total=OrdersTotal();
   for(cnt=0;cnt<total;cnt++)
     {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderMagicNumber()!=Magic_12) continue;
      if(OrderType()<=OP_SELL &&   // check for opened position 
         OrderSymbol()==Symbol())
        {
         if(OrderType()==OP_BUY)   // long position is opened
           {
      
            if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
               MacdCurrent>(MACDCloseLevel_12*Point))
                {
                 OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
                 return(0); // exit
                }
           }
         else // go to short position
           {
      
            if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
               MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel_12*Point))
              {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0); // exit
              }
           }
        }
     }
   return(0);
  }



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////



int OrderTotalMagic (int magicN)
{
int kolvo=0, cnt;
int total=OrdersTotal();
for(cnt=0;cnt<total;cnt++)
   {
   OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
   if(OrderType()<=OP_SELL && OrderSymbol()==Symbol() && OrderMagicNumber()==magicN)
   {kolvo++;}
   }
return (kolvo);
}


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////

//+------------------------------------------------------------------+
//| Сопровождение позиции простым тралом                             |
//+------------------------------------------------------------------+
void TrailingPositions() {
  double pBid, pAsk, pp, TS;

  if(OrderMagicNumber()==Magic_1)  TS=TrailingStop;
  if(OrderMagicNumber()==Magic_2)  TS=TrailingStop_2;
  if(OrderMagicNumber()==Magic_3)  TS=TrailingStop_3;
  if(OrderMagicNumber()==Magic_4)  TS=TrailingStop_4;
  if(OrderMagicNumber()==Magic_5)  TS=TrailingStop_5;
  if(OrderMagicNumber()==Magic_6)  TS=TrailingStop_6;
  if(OrderMagicNumber()==Magic_7)  TS=TrailingStop_7;
  if(OrderMagicNumber()==Magic_8)  TS=TrailingStop_8;
  if(OrderMagicNumber()==Magic_9)  TS=TrailingStop_9;
  if(OrderMagicNumber()==Magic_10) TS=TrailingStop_10;
  if(OrderMagicNumber()==Magic_11) TS=TrailingStop_11;
  if(OrderMagicNumber()==Magic_12) TS=TrailingStop_12;
  
  if(TS<5) return;

  pp = MarketInfo(OrderSymbol(), MODE_POINT);
  if (OrderType()==OP_BUY) {
    pBid = MarketInfo(OrderSymbol(), MODE_BID);
    if (!ProfitTrailing || ND((Bid-OrderOpenPrice()))>ND(TS*pp)) {
      if (ND(OrderStopLoss())<ND(Bid-(TS+TrailingStep-1)*pp) || ND(OrderStopLoss())==0) {
        ModifyStopLoss(ND(Bid-TS*pp));
        return;
      }
    }
  }
  if (OrderType()==OP_SELL) {
    pAsk = MarketInfo(OrderSymbol(), MODE_ASK);
    if (!ProfitTrailing || ND(OrderOpenPrice()-Ask)>ND(TS*pp)) {
      if (ND(OrderStopLoss())>ND(Ask+(TS+TrailingStep-1)*pp) || ND(OrderStopLoss())==0) {
        ModifyStopLoss(ND(Ask+TS*pp));
        return;
      }
    }
  }
}

//+------------------------------------------------------------------+
//| Перенос уровня StopLoss                                          |
//| Параметры:                                                       |
//|   ldStopLoss - уровень StopLoss                                  |
//+------------------------------------------------------------------+
void ModifyStopLoss(double ldStopLoss) {
  bool fm;

  fm=OrderModify(OrderTicket(),ND(OrderOpenPrice()),ND(ldStopLoss),ND(OrderTakeProfit()),0,CLR_NONE);
  if (!fm) Print("Error OrderModify : ",GetLastError());
}
//+------------------------------------------------------------------+


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


double LotSize()
{
    double     lot_min        = MarketInfo( Symbol(), MODE_MINLOT  );
    double     lot_max        = MarketInfo( Symbol(), MODE_MAXLOT  );
    double     lot_step       = MarketInfo( Symbol(), MODE_LOTSTEP );
    double     freemargin     = AccountFreeMargin();
    int        leverage       = AccountLeverage();
    int        lotsize        = MarketInfo( Symbol(), MODE_LOTSIZE );
 
    if( lot_max > MaxLots) {lot_max=MaxLots;}
 
    if( lot_min < 0 || lot_max <= 0.0 || lot_step <= 0.0 || lotsize <= 0 ) 
    {
        Print( "LotSize: invalid MarketInfo() results [", lot_min, ",", lot_max, ",", lot_step, ",", lotsize, "]" );
        return(-1);
    }
    if( leverage <= 0 )
    {
        Print( "LotSize: invalid AccountLeverage() [", leverage, "]" );
        return(-1);
    }
 
    double lot = NormalizeDouble( freemargin * MaximumRisk / leverage / 10.0, 2 );
 
    lot = NormalizeDouble( lot / lot_step, 0 ) * lot_step;
    if ( lot < lot_min ) lot = lot_min;
    if ( lot > lot_max ) lot = lot_max;
 
    double needmargin = NormalizeDouble( lotsize / leverage * Ask * lot, 2 );
 
    if ( freemargin < needmargin )
    {
        Print( "LotSize: We have no money. Free Margin = ", freemargin );
        return(-1);
    }
 
    return(lot);
}


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


double ND (double NormDouble)
{
double NDB = NormalizeDouble (NormDouble, Digits);
return (NDB);
}



///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


bool Trade()
{
if (IsConnected() && IsTradeAllowed()) {return (true);}
else {return (false);}
}


///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////////////////


//--------------------------------------------ОТКРЫВАЕМ BUY-----------------
void OpenBuy(int Stop, int Take, int magicN)
   {
   double   lots=LotSize(); if (lots==0) return; 
   double   loss=0; if (Stop>0) loss=NormalizeDouble(Ask-Stop*Point, Digits);
   double   profit=0; if (Take>0) profit=NormalizeDouble(Ask+Take*Point, Digits); 

   for (int j=0;j<raz;j++)
      {   
         if (OrderSend(Symbol(),OP_BUY,lots,Ask,slipage,loss,profit,"funtik",magicN,0,Green)<0)
               {  
               Print("Error opening BUY order : ",GetLastError());
               if (GetLastError()==138)
                  {
                  Sleep(15000);
                  RefreshRates();
                  continue;
                  }
               }
      break;
      }
   }
//--------------------------------------------------------------------------
//--------------------------------------------------------------------------


//-------------------------------------------ОТКРЫВАЕМ SELL-----------------
void OpenSell(int Stop, int Take, int magicN) 
   { 
   double   lots=LotSize(); if (lots==0) return; 
   double   loss=0; if (Stop>0) loss=NormalizeDouble(Bid+Stop*Point, Digits); 
   double   profit=0; if (Take>0) profit=NormalizeDouble(Bid-Take*Point, Digits); 
   
   for (int j=0;j<raz;j++)
      {   
         if (OrderSend(Symbol(),OP_SELL,lots,Bid,slipage,loss,profit,"funtik",magicN,0,Red)<0)
               {  
               Print("Error opening BUY order : ",GetLastError());
               if (GetLastError()==138)
                  {
                  Sleep(15000);
                  RefreshRates();
                  continue;
                  }
               }
      break;
      }
   }   

//--------------------------------------------------------------------------
//--------------------------------------------------------------------------

/////////////////////            КОНЕЦ             /////////////////////////