Expert Advisor - Phoenix-5-6-03

Expert Advisor

Phoenix Expert Advisor Forex è molto complicato EA.
Esso utilizza molti standard MetaTrader 4 indicatori (come le medie mobili e buste) per determinare la posizione di entrata e di uscita così come i parametri di posizione.
Questo consulente esperto ha molti parametri di input e memorizzati internamente set di dati per ciascuna delle cinque coppie di valute può essere utilizzato per il commercio con.
L'abbondanza degli indicatori e dei controlli condizionale fare consulente esperto Phoenix un po 'più lenta della CPU per l'elaborazione.

La prova del MetaTrader Expert advisor Phoenix ha portato circa 6.400 dollari di profitto con GBP/USD su un time frame di 15 minuti con 1 lotto standard per aprire posizioni.
Il test è stato fatto nel corso di un periodo di un anno, con massimo drawdown un minimo di € 96.
Ho anche controllato su un periodo di tre anni e ha dimostrato le stesse prestazioni.

MiniFAQ
Quali sono gli stop-loss e take-profit utilizzato da questo EA?

Esso utilizza la variabile di stop-loss e take-profit, ma la media vincere e perdere la posizione resa pips 138 e 148, in media, rispettivamente.

Quanto spesso trada?

Il 15 minuti di GBP / USD grafico (le impostazioni ottimali) questo EA commercio 1 volta al giorno in media.

//+------------------------------------------------------------------+
//|                                             Phoenix_5_6_03.mq4   |
//|                                       Copyright © 2006, Hendrick |
//|                                                                  |
//+------------------------------------------------------------------+

#property copyright "Copyright © 2006, Hendrick."

#define MAGICMA_A  20050610
#define MAGICMA_B  20060611

#define MAGICMA01  20050612
#define MAGICMA02  20060613
#define MAGICMA03  20060614

extern string     GeneralSettings         = "===== General Settings ============================";
extern int        PhoenixMode             = 3;
extern double     Lots                    = 1;
extern double     MaximumRisk             = 0.05;
extern int        DecreaseFactor          = 0;
extern bool       MM                      = true;
extern bool       AccountIsMicro          = false;

extern bool       PrefSettings            = true;

extern int        CloseAfterHours         = 0;
extern int        BreakEvenAfterPips      = 0;

extern string     Mode1                   = "====== Phoenix Mode 1 (Classic) ==================";
extern int        TakeProfit              = 0;
extern int        StopLoss                = 0;
extern int        TrailingStop            = 0;

extern string     Mode2                   = "====== Phoenix Mode 2 (Second trade)==============";
extern int        Mode2_OpenTrade_2       = 0;
extern int        Mode2_TakeProfit        = 0;
extern int        Mode2_StopLoss          = 0;
extern bool       Mode2_CloseFirstTrade   = false;
     
extern string     Mode3                   = "====== Phoenix Mode 3 (Three trades at once) =====";
extern int        Mode3_CloseTrade2_3     = 0;
extern int        Mode3_TakeProfit        = 0;
extern int        Mode3_StopLoss          = 0;

extern string     Signal1                 = "====== Signal 1 ===================================";
extern bool       UseSignal1              = true;
extern double     Percent                 = 0;
extern int        EnvelopePeriod          = 0;

extern string     Signal2                 = "====== Signal 2 ==================================";
extern bool       UseSignal2              = true;
extern int        SMAPeriod               = 0;
extern int        SMA2Bars                = 0;

extern string     Signal3                 = "====== Signal 3 ==================================";
extern bool       UseSignal3              = true;
extern int        OSMAFast                = 0;
extern int        OSMASlow                = 0;
extern double     OSMASignal              = 0;

extern string     Signal4                 = "====== Signal 4 ==================================";
extern bool       UseSignal4              = true;
extern int        Fast_Period             = 0;
extern int        Fast_Price              = PRICE_OPEN;
extern int        Slow_Period             = 0;
extern int        Slow_Price              = PRICE_OPEN;
extern double     DVBuySell               = 0;
extern double     DVStayOut               = 0;

extern string     Signal5                 = "====== Signal 5 =================================";
extern bool       UseSignal5              = true;
extern int        TradeFrom1              = 0;
extern int        TradeUntil1             = 24;
extern int        TradeFrom2              = 0;
extern int        TradeUntil2             = 0;
extern int        TradeFrom3              = 0;
extern int        TradeUntil3             = 0;
extern int        TradeFrom4              = 0;
extern int        TradeUntil4             = 0;

double Poin;

int init()
{
   //Checking for unconvetional Point digits number
   if (Point == 0.00001) Poin = 0.0001; //5 digits
   else if (Point == 0.001) Poin = 0.01; //3 digits
   else Poin = Point; //Normal

//+------------------------------------------------------------------+
//| START Preffered Settings                                         |
//+------------------------------------------------------------------+

if(PrefSettings == true)
{
   if((Symbol() == "USDJPY") || (Symbol() == "USDJPYm"))
      {     
  
      Mode2_OpenTrade_2    = 0;
      Mode2_TakeProfit     = 50;
      Mode2_StopLoss       = 60;
      

      Mode3_CloseTrade2_3  = 30;
      Mode3_TakeProfit     = 100;
      Mode3_StopLoss       = 55;
      
      Percent              = 0.0032;
      EnvelopePeriod       = 2;
      
      TakeProfit           = 42;
      StopLoss             = 84;
      TrailingStop         = 0;
      SMAPeriod            = 2;
      SMA2Bars             = 18;
      OSMAFast             = 5;
      OSMASlow             = 22;
      OSMASignal           = 2;
      
      Fast_Period          = 25;
      Slow_Period          = 15;
      DVBuySell            = 0.0029;
      DVStayOut            = 0.024;
      }

   if((Symbol() == "EURJPY") || (Symbol() == "EURJPYm"))
      {
      
      Mode2_OpenTrade_2    = 18;
      Mode2_TakeProfit     = 70;
      Mode2_StopLoss       = 30;
      

      Mode3_CloseTrade2_3  = 55;
      Mode3_TakeProfit     = 70;
      Mode3_StopLoss       = 80;      

      Percent              = 0.007;
      EnvelopePeriod       = 2;
      
      TakeProfit           = 42;
      StopLoss             = 84;
      TrailingStop         = 0;
      SMAPeriod            = 4;
      SMA2Bars             = 16;
      OSMAFast             = 11;
      OSMASlow             = 20;
      OSMASignal           = 14;
      
      Fast_Period          = 20;
      Slow_Period          = 10;
      DVBuySell            = 0.0078;
      DVStayOut            = 0.026;
      }

   if((Symbol() == "GBPJPY") || (Symbol() == "GBPJPYm"))
      {
      
      Mode2_OpenTrade_2    = 2;
      Mode2_TakeProfit     = 130;
      Mode2_StopLoss       = 80;
      

      Mode3_CloseTrade2_3  = 40;
      Mode3_TakeProfit     = 90;
      Mode3_StopLoss       = 80;      

      
      Percent              = 0.0072;
      EnvelopePeriod       = 2;
      
      TakeProfit           = 42;
      StopLoss             = 84;
      TrailingStop         = 0;
      SMAPeriod            = 8;
      SMA2Bars             = 12;
      OSMAFast             = 5;
      OSMASlow             = 36;
      OSMASignal           = 10;
      
      Fast_Period          = 17;
      Slow_Period          = 28;
      DVBuySell            = 0.0034;
      DVStayOut            = 0.063;
      }
      
   if((Symbol() == "USDCHF") || (Symbol() == "USDCHFm"))
      {
      
      Mode2_OpenTrade_2    = 10;
      Mode2_TakeProfit     = 90;
      Mode2_StopLoss       = 65;
      

      Mode3_CloseTrade2_3  = 85;
      Mode3_TakeProfit     = 130;
      Mode3_StopLoss       = 80;      

      
      Percent              = 0.0056;
      EnvelopePeriod       = 10;
      
      TakeProfit           = 42;
      StopLoss             = 84;
      TrailingStop         = 0;
      SMAPeriod            = 5;
      SMA2Bars             = 9;
      OSMAFast             = 5;
      OSMASlow             = 12;
      OSMASignal           = 11;
      
      Fast_Period          = 5;
      Slow_Period          = 20;
      DVBuySell            = 0.00022;
      DVStayOut            = 0.0015;
      }
      
   if((Symbol() == "GBPUSD") || (Symbol() == "GBPUSDm"))
      {
      
      Mode2_OpenTrade_2    = 5;
      Mode2_TakeProfit     = 95;
      Mode2_StopLoss       = 90;
      

      Mode3_CloseTrade2_3  = 90;
      Mode3_TakeProfit     = 110;
      Mode3_StopLoss       = 80;      

      
      Percent              = 0.0023;
      EnvelopePeriod       = 6;
      
      TakeProfit           = 42;
      StopLoss             = 84;
      TrailingStop         = 0;
      SMAPeriod            = 3;
      SMA2Bars             = 14;
      OSMAFast             = 23;
      OSMASlow             = 17;
      OSMASignal           = 15;
      
      Fast_Period          = 25;
      Slow_Period          = 37;
      DVBuySell            = 0.00042;
      DVStayOut            = 0.05;
      }      
}
return(0);
}

//+------------------------------------------------------------------+
//| END Preffered Settings                                           |
//+------------------------------------------------------------------+



//+------------------------------------------------------------------+
//| START EA                                                         |
//+------------------------------------------------------------------+

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

   if(PhoenixMode==1)//Phoenix Classic
      {
      CheckOpenTrade();     
      if(CloseAfterHours != 0)  CheckCloseAfterHours();
      if(!StopLoss==0)              CheckTrailingStop();
      if(BreakEvenAfterPips != 0)        CheckBreakEven();
      }
      
         
   if(PhoenixMode==2)//Phoenix Second Trade
      {
      CheckOpenTrade();     
      if(CloseAfterHours != 0)  CheckCloseAfterHours();
      CheckSecondTrade();
      }

   if(PhoenixMode==3)//Phoenix 123
      {
      CheckOpenTradeMode123();     
      Mode3_MoveSL_Trade_2_3();
      Mode3_MoveSL_Trade_3();
      if(Mode3_CloseTrade2_3 != 0) CheckCloseTrade23();
      }
      
   } 
     
//+------------------------------------------------------------------+
//| END EA                                                           |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Calculate open positions                          |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
  {
   int count=0;

   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(OrderSymbol()==Symbol() && (OrderMagicNumber()==MAGICMA_A || OrderMagicNumber()==MAGICMA_B))
        {
         count++;
        }
     }
     return(count);
  }
//+------------------------------------------------------------------+
//| STOP Function Calculate open positions                           |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Check Open Trade                                  |
//+------------------------------------------------------------------+
int CheckOpenTrade()
{      
int Signal=0, err = 0, total = OrdersTotal();

if(CalculateCurrentOrders(Symbol()) < 1)
   {  
   if(CheckSignal(Signal)==1)
      {
      if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid+StopLoss*Poin,Bid-TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Red) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
       return(0);
      }
      
   if(CheckSignal(Signal)==2)
      {
      if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask-StopLoss*Poin,Ask+TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Blue) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      return(0);
      }
   }
}
//+------------------------------------------------------------------+
//| END Function Check Open Trade                                    |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START MODE 3 Function Check Open Trade                           |
//+------------------------------------------------------------------+
int CheckOpenTradeMode123()
{
     
int Signal = 0, err = 0, total = OrdersTotal(), decimalPlaces=1;
if(AccountIsMicro==true) decimalPlaces=2;
double lots123 = NormalizeDouble(LotsOptimized()/3,decimalPlaces);

if(lots123 < 0.1 && AccountIsMicro==false) {lots123=0.1;}
if(lots123 < 0.01 && AccountIsMicro==true) {lots123=0.01;}

if(Mode3CalculateCurrentOrders(Symbol()) < 1)      
   {
   if(CheckSignal(Signal)==1)
      {
      if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Red)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
           
      if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Red)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      
      if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Red)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      return(0);
      }
      
   if(CheckSignal(Signal)==2)
      {
      if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Blue)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }      
      if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Blue)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Blue)<0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      return(0);
      }
   } 
}

//+------------------------------------------------------------------+
//| END Function Check Open Trade                                    |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Check Second Trade                                |
//+------------------------------------------------------------------+

void CheckSecondTrade()
{
int err = 0, total = OrdersTotal();

for(int z = total - 1; z >= 0; z --)
   {
   if(!OrderSelect( z, SELECT_BY_POS))
      {
      err = GetLastError();
      Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
      continue;
      }

   if(OrderSymbol() != Symbol()) continue;

   if(OrderMagicNumber() == MAGICMA_B) break;
 
   if(OrderMagicNumber() != MAGICMA_A) continue;

   if(OrderType() == OP_BUY && (Bid-OrderOpenPrice() > Poin*Mode2_OpenTrade_2))
      {   
      if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask - Mode2_StopLoss * Poin,Ask + Mode2_TakeProfit * Poin,"Mode2_SecondTrade",MAGICMA_B,0,Blue) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
      return(0);  
      }

   if(OrderType() == OP_SELL && (OrderOpenPrice()-Ask > Poin*Mode2_OpenTrade_2))
      {
      if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid + Mode2_StopLoss * Poin,Bid - Mode2_TakeProfit*Poin,"Mode2_SecondTrade",MAGICMA_B,0,Red) < 0)
         {
         err = GetLastError();
         Print("Error Ordersend(",err,"): ");
         return(-1);
         }
      if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
      return(0);
      }
   }            

}

//+------------------------------------------------------------------+
//| END Function Check Second Trade                                  |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Check Close Trade 2 And 3                         |
//+------------------------------------------------------------------+
void CheckCloseTrade23()
{

int err = 0, total = OrdersTotal();
bool CloseTrade=false;

for(int z = total - 1; z >= 0; z --)
   {
   if(!OrderSelect( z, SELECT_BY_POS))
      {
      err = GetLastError();
      Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
      continue;
      }

   if(OrderSymbol() != Symbol()) continue;

   if(OrderMagicNumber() != MAGICMA01) continue;
   
   if(OrderType() == OP_BUY && (OrderOpenPrice()-Bid > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;}
   if(OrderType() == OP_SELL && (Ask-OrderOpenPrice() > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;}

   if(CloseTrade)
      {
      for(int y = total - 1; y >= 0; y --)
         {
         if(!OrderSelect( y, SELECT_BY_POS))
            {
            err = GetLastError();
            Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
            continue;
            }
         if(OrderSymbol() != Symbol()) continue;

         if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
            {
            if(OrderType() == OP_BUY)
               {
               if(OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet)<0)
                  {
                  err = GetLastError();
                  Print("Error Ordersend(",err,"): ");
                  return(-1);
                  }
               return(0); 
               }
            if(OrderType() == OP_SELL)
               {
               if(OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet)<0)
                  {      
                  err = GetLastError();
                  Print("Error Ordersend(",err,"): ");
                  return(-1);
                  }
              return(0); 
               }
             }
}
}
}
}


//+------------------------------------------------------------------+
//| END Function Check Close Trade 2 And 3                               |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Check First Trade Mode3                                         |
//+------------------------------------------------------------------+

void Mode3_MoveSL_Trade_2_3()
{

int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false;

for(int z = history - 1; z >= 0; z --)
   {
   if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
      {
      err = GetLastError();
      Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
      continue;
      }

   if(OrderSymbol() != Symbol()) continue;

   if(OrderMagicNumber() == MAGICMA03) break;
   
   if(OrderMagicNumber() == MAGICMA02) break;
 
   if(OrderMagicNumber() != MAGICMA01) continue;

   if(OrderProfit() > 0) 
      {
      ChangeStopLoss=true;
      break;
      }
   }


  if(ChangeStopLoss==true)
   {
   for(int y = total - 1; y >= 0; y --)
      {
      if(!OrderSelect(y,SELECT_BY_POS))
         {
         err = GetLastError();
         Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
         continue;
         }

      if(OrderSymbol() != Symbol()) continue;

      if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
         {
         if(OrderType()==OP_BUY)
            {
            if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
            {
            err = GetLastError();
            Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
            continue;
            }
//         return(0);  
         }

         if(OrderType()==OP_SELL)
         {
         if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
            {
            err = GetLastError();
            Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
            continue;
            }
//         return(0);  
         }
}      
}
}
}
//}
//+------------------------------------------------------------------+
//| END Check First Trade Mode 3                                     |
//+------------------------------------------------------------------+
 
 
//+------------------------------------------------------------------+
//| START Check Second Trade Mode3                                   |
//+------------------------------------------------------------------+

void Mode3_MoveSL_Trade_3()
{

double NewSLTrade3B,NewSLTrade3S;
int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false;

for(int z = history - 1; z >= 0; z --)
   {
   if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
      {
      err = GetLastError();
      Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
      continue;
      }

   if(OrderSymbol() != Symbol()) continue;

   if(OrderMagicNumber() == MAGICMA03) break;
   
   if(OrderMagicNumber() == MAGICMA01) break;
 
   if(OrderMagicNumber() != MAGICMA02) continue;

   if(OrderProfit() > 0) 
      {
      for(int y = total - 1; y >= 0; y --)
         {
         if(!OrderSelect(y,SELECT_BY_POS))
            {
            err = GetLastError();
            Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
            continue;
            }

         if(OrderSymbol() != Symbol()) continue;

         if(OrderMagicNumber() == MAGICMA03)
            {
            if(OrderType()==OP_BUY)
               {
               NewSLTrade3B=OrderOpenPrice()+NormalizeDouble(((OrderTakeProfit()-OrderOpenPrice())/2),Digits);
               if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3B,OrderTakeProfit(),0,GreenYellow)<0)
                  {
                  err = GetLastError();
                  Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
                  continue;
                  }
               return(0);  
               }

            if(OrderType()==OP_SELL)
               {
               NewSLTrade3S=OrderOpenPrice()-NormalizeDouble(((OrderOpenPrice()-OrderTakeProfit())/2),Digits);
               if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3S,OrderTakeProfit(),0,GreenYellow)<0)
                  {
                  err = GetLastError();
                  Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
                  continue;
                  }
               return(0);  
               }
}      
}
}
}
}

//+------------------------------------------------------------------+
//| END Check Second Trade Mode 3                                    |
//+------------------------------------------------------------------+ 
 
  
//+------------------------------------------------------------------+
//| START Function Diverge                                           |
//+------------------------------------------------------------------+

double divergence(int F_Period, int S_Period, int F_Price, int S_Price, int mypos)
  {
    int i;
    double maF1, maF2, maS1, maS2;

    maF2 = iMA(Symbol(), 0, F_Period, 0, MODE_SMA, F_Price, mypos + 1);
    maS2 = iMA(Symbol(), 0, S_Period, 0, MODE_SMA, S_Price, mypos + 1);

    return(maF2-maS2);
  }

//+------------------------------------------------------------------+
//| END Function Diverge                                             |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Valid Trade Time                                  |
//+------------------------------------------------------------------+

bool F_ValidTradeTime (int iHour)
   {
      if(((iHour >= TradeFrom1) && (iHour <= (TradeUntil1-1)))||((iHour>= TradeFrom2) && (iHour <= (TradeUntil2-1)))||((iHour >= TradeFrom3)&& (iHour <= (TradeUntil3-1)))||((iHour >= TradeFrom4) && (iHour <=(TradeUntil4-1))))
      {
       return (true);
      }
      else
       return (false);
   }  

//+------------------------------------------------------------------+
//| END Function Valid Trade Time                                    |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Check Close Trade After x Hours                            |
//+------------------------------------------------------------------+

void CheckCloseAfterHours()
{
int total = OrdersTotal();

for(int cnt=0;cnt<total;cnt++)
   {
   OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
   if(OrderType()<=OP_SELL &&
      OrderSymbol()==Symbol() &&
      OrderMagicNumber()==MAGICMA_A)
      {            
         if((CurTime()-OrderOpenTime())>(CloseAfterHours*3600) && OrderProfit()<0)
            {
            OrderClose(OrderTicket(),OrderLots(),Bid,10,Violet);
            }
      }
   }
}

//+------------------------------------------------------------------+
//| END Check Close Trade After x Hours                              |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Check Signals                                     |
//+------------------------------------------------------------------+

//=====================SIGNAL1========================
int CheckSignal(int Signal)
{
Signal=0;

bool BuySignal1=false, SellSignal1=false;

double HighEnvelope1 = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_UPPER,1);
double LowEnvelope1  = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_LOWER,1);
double CloseBar1     = iClose(NULL,0,1);

if(UseSignal1)
{
   if(CloseBar1 > HighEnvelope1) {SellSignal1 = true;} 
   if(CloseBar1 < LowEnvelope1)  {BuySignal1  = true;}
}
else {SellSignal1=true;BuySignal1=true;}



//=====================SIGNAL2========================

bool BuySignal2=false, SellSignal2=false;

double SMA1=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,1);
double SMA2=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,SMA2Bars);

if(UseSignal2)
{
   if(SMA2-SMA1>0) {BuySignal2  = true;}
   if(SMA2-SMA1<0) {SellSignal2 = true;}
}
else {SellSignal2=true;BuySignal2=true;}



//=====================SIGNAL3========================

bool BuySignal3=false, SellSignal3=false;

double OsMABar2=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,2);
double OsMABar1=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,1);

if(UseSignal3)
{
   if(OsMABar2 > OsMABar1)  {SellSignal3 = true;}
   if(OsMABar2 < OsMABar1)  {BuySignal3  = true;}
}
else {SellSignal3=true;BuySignal3=true;}


      
//=====================SIGNAL4========================  

   double diverge;
   bool BuySignal4=false,SellSignal4=false;
   
   diverge = divergence(Fast_Period, Slow_Period, Fast_Price, Slow_Price,0);

if(UseSignal4)
{
   if(diverge >= DVBuySell && diverge <= DVStayOut)
       {BuySignal4 = true;}
   if(diverge <= (DVBuySell*(-1)) && diverge >= (DVStayOut*(-1))) 
       {SellSignal4 = true;} 
}       
else {SellSignal4=true;BuySignal4=true;}


    
//=====================SIGNAL5=======================  

bool BuySignal5=false, SellSignal5=false;

if(UseSignal5)
{
   int iHour=TimeHour(LocalTime());
   int ValidTradeTime = F_ValidTradeTime(iHour);
   if(ValidTradeTime==true)
    {
    BuySignal5=true;
    SellSignal5=true;
    }
}
else {SellSignal5=true;BuySignal5=true;}

if((SellSignal1==true) && (SellSignal2==true) && (SellSignal3==true) && (SellSignal4==true) && (SellSignal5==true)) return(1);  
if((BuySignal1==true) && (BuySignal2==true) && (BuySignal3==true) && (BuySignal4==true) && (BuySignal5==true)) return(2);
}

//+------------------------------------------------------------------+
//| END Function Check Signals                                       |
//+------------------------------------------------------------------+   

//+------------------------------------------------------------------+
//| START Calculate optimal lot size                                 |
//+------------------------------------------------------------------+

double LotsOptimized()
  {
  if(MM==false) return(Lots);
   double lot=Lots;
   int    orders=HistoryTotal();
   int    losses=0;
   int    decimalPlaces=1;
   
   if(AccountIsMicro==true) decimalPlaces=2;

   lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000.0,decimalPlaces);
   if(DecreaseFactor>0)
     {
      for(int i=orders-1;i>=0;i--)
        {
         if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) { Print("Error in history!"); break; }
         if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
         //----
         if(OrderProfit()>0) break;
         if(OrderProfit()<0) losses++;
        }
      if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,decimalPlaces);
     }

   if(lot<0.1 && AccountIsMicro==false) lot=0.1;
   if(lot<0.01 && AccountIsMicro==true) lot=0.01;
   if(lot>99) lot=99;
   return(lot);

  }
  
//+------------------------------------------------------------------+
//| END Calculate optimal lot size                                   |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Check TrailingStop                                |
//+------------------------------------------------------------------+
void CheckTrailingStop()
{
   for(int i=0;i<OrdersTotal();i++)
      {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
      if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
   
      if(OrderType() == OP_BUY)
         {
         if(((Bid - OrderOpenPrice()) > (Poin * TrailingStop)) && (OrderStopLoss() < (Bid - Poin * TrailingStop)))
            OrderModify(
                        OrderTicket(),
                        OrderOpenPrice(),
                        Bid - Poin * TrailingStop,
                        OrderTakeProfit(),
                        0,
                        GreenYellow);
         }
      
      if(OrderType() == OP_SELL)
         {
         if(((OrderOpenPrice() - Ask) > (Poin * TrailingStop)) && (OrderStopLoss() > (Ask + Poin * TrailingStop)))
            OrderModify(
                        OrderTicket(),
                        OrderOpenPrice(),
                        Ask + Poin * TrailingStop,
                        OrderTakeProfit(),
                        0,
                        Red);
         }            
      }
}
//+------------------------------------------------------------------+
//| END Function Check TrailingStop                                  |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| START Function Check BreakEven                                   |
//+------------------------------------------------------------------+

void CheckBreakEven()
{
for(int i=0;i<OrdersTotal();i++)
      {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
      if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
   
      if(OrderType() == OP_BUY)
         {
         if((Bid-OrderOpenPrice()) > (Poin*BreakEvenAfterPips))
            OrderModify(
                        OrderTicket(),
                        OrderOpenPrice(),
                        OrderOpenPrice(),
                        OrderTakeProfit(),
                        0,
                        GreenYellow);
         }
      
      if(OrderType() == OP_SELL)
         {
         if((OrderOpenPrice()-Ask) > (Poin*BreakEvenAfterPips))
            OrderModify(
                        OrderTicket(),
                        OrderOpenPrice(),
                        OrderOpenPrice(),
                        OrderTakeProfit(),
                        0,
                        Red);
         }            
      }
}

//+------------------------------------------------------------------+
//| END Function Check BreakEven                                 |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| START Function Close First Trade                                 |
//+------------------------------------------------------------------+


int CloseFirstTrade()
{
   for(int i=0;i<OrdersTotal();i++)
      {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
      if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
      
         OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); 
         return(0); 
      }
}  
//+------------------------------------------------------------------+
//| END Function Close First Trade                                   |
//+------------------------------------------------------------------+


//+------------------------------------------------------------------+
//| START Function Calculate Current Orders Mode 3                   |
//+------------------------------------------------------------------+
int Mode3CalculateCurrentOrders(string symbol)
  {
   int buys=0,sells=0;

   for(int i=0;i<OrdersTotal();i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
      if(
      (OrderSymbol()==Symbol()) && 
      ((OrderMagicNumber()==MAGICMA01) ||
       (OrderMagicNumber()==MAGICMA02) || 
       (OrderMagicNumber()==MAGICMA03)))
        {
         if(OrderType()==OP_BUY)  buys++;
         if(OrderType()==OP_SELL) sells++;
        }
     }
    return(buys+sells);
  }
//+------------------------------------------------------------------+
//| STOP Function Calculate Current Orders Mode 3                    |
//+------------------------------------------------------------------+