SimpleGrail





//+------------------------------------------------------------------+
//|                                                  SimpleGrail.mq4 |
//|                                        Copyright © 2009, LEHayes |
//|                                   BlessingsFromEarth@hotmail.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2009, LEHayes"
#property link      "BlessingsFromEarth@hotmail.com"


extern int    StopLoss       = 0;            // if using 4 digits, set to 20 on Trailing stop loss
extern int    TrailingStop   = 200;   // represents 20 lots with the extra digit
extern bool   choice         = true;
double Lots           = 0.1;           // This is legacy, no switch at this time for progressive lots
extern int    magicnumber    = 143;
bool   PolLots        = false;         // This closes half the lots at some point, without it, more earnings.
extern int    MaxOrders      =  1;     // you can place multiple orders, but suffer equity risk
extern double Prots= 15;                                  // Percentage of free assets


double Lot;                         // global lot for calculating free assets
int prevtime;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
//----


  Lots = GetLots();


   int i=0;  
   int total = OrdersTotal();   
   for(i = 0; i <= total; i++) 
     {
      if(TrailingStop>0)  
       {                 
       OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
       if(OrderMagicNumber() == magicnumber) 
         {
         TrailingStairs(OrderTicket(),TrailingStop);
         }
       }
      }

if(AccountFreeMargin() > (AccountBalance()/2))
{
bool BuyOp=false;
bool SellOp=false;


if (High[0]>High[1]&&High[1]>High[2]&&High[2]>High[3]&&Open[0]>Open[1]&&Open[1]>Open[2]&&Open[2]>Open[3]) BuyOp=true;
if (High[0]<High[1]&&High[1]<High[2]&&High[2]<High[3]&&Open[0]<Open[1]&&Open[1]<Open[2]&&Open[2]<Open[3]) SellOp=true;

   if(Time[0] == prevtime) 
       return(0);
   prevtime = Time[0];
   if(!IsTradeAllowed()) 
     {
       prevtime = Time[1];
       return(0);
     }


   if (total < MaxOrders || MaxOrders == 0)
     {   
       if(BuyOp)
        { 
         if (StopLoss!=0)
          {
           HouseKeeper(1);
           OrderSend(Symbol(),OP_BUY,Lots,Ask,3,Bid-(StopLoss*Point),0,StringConcatenate("SimpleGrail_", Symbol(), "_Buy"),magicnumber,0,Green);
          }
         else
          {
           HouseKeeper(1);
           OrderSend(Symbol(),OP_BUY,Lots,Ask,3,0,0,StringConcatenate("SimpleGrail_",Symbol(), "_Buy"),magicnumber,0,Green);
          }
        }
       if(SellOp)
        { 
         if (StopLoss!=0)
          {
          HouseKeeper(2);
           OrderSend(Symbol(),OP_SELL,Lots,Bid,3,Ask+(StopLoss*Point),0,StringConcatenate("SimpleGrail_", Symbol(), "_Sell"),magicnumber,0,Red);
          } 
         else 
          {
           HouseKeeper(2);
           OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,0,StringConcatenate("SimpleGrail_", Symbol(), "_Sell"),magicnumber,0,Red);
          }
        }
      }
}   
//----
   return(0);
  } 
  
//+------------------------------------------------------------------+
int HouseKeeper(int BuySell)
   {
   
      int i=0;
      int HKtotal = OrdersTotal();   
      bool IsClosed = false;
      
      choice = true;
      
      if (choice)
         {
            for(i = 0; i <= HKtotal; i++) 
               {
                  OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
                  IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                  if (IsClosed == false)
                     {
                         // try again
                         IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                     }
               }
         }
      else
         {
            for(i = 0; i <= HKtotal; i++) 
               {
                  OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
                  if(OrderMagicNumber() == magicnumber) 
                     {
                           
                        if (BuySell ==1)
                           {
                              if (OrderType() == OP_SELL)
                                 {
                                    if (OrderProfit() < 0)
                                       {
                                          IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                                          if (IsClosed == false)
                                             {
                                                // try again
                                                IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                                             }
                                       }
                                 }
                           }
                        else
                           {
                              if (OrderType() == OP_BUY)
                                 {
                                    if (OrderProfit() < 0)
                                       {
                                          IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                                          if (IsClosed == false)
                                             {
                                                // try again
                                                IsClosed = OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(),3,Yellow);
                                             }
                                       }
                                 }                     
                           }
                  }
               }
         }      
   
      return(0);
   }


double GetLots()
   {
   
   Lot = NormalizeDouble( (AccountFreeMargin()/MaxOrders)*Prots/100/1000, 1);// Calculate the amount of lots 
   Print("Lot calculation is: ", Lot); 
   if (Lot < MarketInfo(Symbol(),MODE_MINLOT))
      {
         Lot = MarketInfo(Symbol(),MODE_MINLOT);       // For testing on const. min. lots
         Print("Lot is too small, setting to minlot of: ", Lot);
      }
   return(Lot);
   }  
  
//+------------------------------------------------------------------+
void TrailingStairs(int ticket,int trldistance)
   {
    bool result;
    int error;
    int Spred=Ask - Bid;
    int spread;
    
    if (OrderType()==OP_BUY)
      {
       if((Bid-OrderOpenPrice())>(Point*trldistance))
         {
          if(OrderStopLoss()<Bid-Point*trldistance || (OrderStopLoss()==0))
            {
             result=OrderModify(ticket,OrderOpenPrice(),Bid-Point*trldistance,OrderTakeProfit(),0,Green);
             while(result!=True)
               {
                  error=GetLastError();
                  Print("LastError closing first try =",error);
                  if(error==138)
                  {
                     Sleep(10000);
                     RefreshRates();
                     result=OrderModify(ticket,OrderOpenPrice(),Bid-Point*trldistance,OrderTakeProfit(),0,Green);
                  }
                  if(error==0)
                   {
                      result=true;
                   }
               }
           
            
             if (PolLots)
                if (NormalizeDouble(OrderLots()/2,2)>MarketInfo(Symbol(), MODE_MINLOT))
                  {
                     spread=MarketInfo(Symbol(),MODE_SPREAD); 
                     result = OrderClose(ticket,NormalizeDouble(OrderLots()/2,2),Ask,spread,Green);
                     while(result!=True)
                     {
                        error=GetLastError();
                        Print("1 LastError closing first try =",error);
                        if(error==138)
                          {
                              Sleep(10000);
                              RefreshRates();
                              spread=MarketInfo(Symbol(),MODE_SPREAD);
                              result = OrderClose(ticket,NormalizeDouble(OrderLots()/2,2),Ask,spread,Green);
                           }
                        if(error==0)
                           {
                              result=true;
                           }
                     }
                     
                  }
                else
                  {
                     spread=MarketInfo(Symbol(),MODE_SPREAD);
                     result = OrderClose(ticket,OrderLots(),Ask,spread,Green);
                     while(result!=True)
                     {
                        error=GetLastError();
                        Print("2 LastError closing first try =",error);
                        if(error==138)
                           {
                              Sleep(10000);
                              RefreshRates();
                              spread=MarketInfo(Symbol(),MODE_SPREAD);
                              result = OrderClose(ticket,OrderLots(),Ask,spread,Green);
                           }
                        if(error==0)
                           {
                              result=true;
                           }
                     }
                  }
            }
         }
       }
     else
       {
        if((OrderOpenPrice()-Ask)>(Point*trldistance))
          {
           if((OrderStopLoss()>(Ask+Point*trldistance)) || (OrderStopLoss()==0))
             {
               result=OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*trldistance,OrderTakeProfit(),0,Red);
               while(result!=True)
                  {
                     error=GetLastError();
                     Print("LastError closing first try =",error);
                     if(error==138)
                        {
                           Sleep(10000);
                           RefreshRates();
                           result=OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*trldistance,OrderTakeProfit(),0,Red);
                        }
                        if(error==0)
                           {
                              result=true;
                           }
                  }
             if (PolLots)
             if (NormalizeDouble(OrderLots()/2,2)>MarketInfo(Symbol(), MODE_MINLOT))
               {
                  spread=MarketInfo(Symbol(),MODE_SPREAD);
                  result = OrderClose(ticket,NormalizeDouble(OrderLots()/2,2),Bid,spread,Green);
                  while(result!=True)
                  {
                     error=GetLastError();
                     Print("3 LastError closing first try =",error);
                     if(error==138)
                        {
                           Sleep(10000);
                           RefreshRates();
                           spread=MarketInfo(Symbol(),MODE_SPREAD);
                           result = OrderClose(ticket,NormalizeDouble(OrderLots()/2,2),Bid,spread,Green);
                        }
                        if(error==0)
                           {
                              result=true;
                           }
                  }
                  
               }
             else
               {
                  spread=MarketInfo(Symbol(),MODE_SPREAD);
                  result = OrderClose(ticket,OrderLots(),Bid,spread,Green);
                  while(result!=true)
                  {
                     error=GetLastError();
                     Print("4 LastError closing first try =",error);
                     if(error==138)
                        {
                           Sleep(10000);
                           RefreshRates();
                           spread=MarketInfo(Symbol(),MODE_SPREAD);
                           result = OrderClose(ticket,NormalizeDouble(OrderLots()/2,2),Bid,spread,Green);
                        }
                        if(error==0)
                           {
                              result=true;
                           }
                  }

               }
             }
          }
        }
    }





Sample





Analysis



Market Information Used:

Series array that contains the highest prices of each bar
Series array that contains open prices of each bar
Series array that contains open time of each bar


Indicator Curves created:


Indicators Used:



Custom Indicators Used:

Order Management characteristics:
Checks for the total of open orders

It automatically opens orders when conditions are reached
It Closes Orders by itself
It can change open orders parameters, due to possible stepping strategy

Other Features:

BackTest : EURUSD on H1

From 2009-08-01 to 2009-10-01 Profit Factor:0.18 Total Net Profit:-9958.00

BackTest : EURUSD on H1

From 2009-11-01 to 2009-11-30 Profit Factor:0.18 Total Net Profit:-4800.72

BackTest : EURUSD on H1

From 2009-12-01 to 2010-01-17 Profit Factor:2.26 Total Net Profit:4760.70

BackTest : EURUSD on H1

From 2010-03-01 to 2010-03-27 Profit Factor:1.44 Total Net Profit:1339.20

BackTest : EURUSD on H1

From 2010-04-01 to 2010-04-30 Profit Factor:16.88 Total Net Profit:3834.30

BackTest : EURUSD on H1

From 2010-05-01 to 2010-05-31 Profit Factor:6.56 Total Net Profit:13379.34

BackTest : EURUSD on H1

From 2010-06-01 to 2010-06-30 Profit Factor:0.33 Total Net Profit:-3683.96

BackTest : GBPUSD on H1

From 2010-01-01 to 2010-02-27 Profit Factor:0.00 Total Net Profit:8729.40

BackTest : GBPUSD on H1

From 2010-01-01 to 2010-04-16 Profit Factor:0.40 Total Net Profit:-7421.70

BackTest : USDCAD on H1

From 2009-01-01 to 2010-01-01 Profit Factor:0.06 Total Net Profit:-10177.88

BackTest : USDCAD on H1

From 2009-12-01 to 2010-01-01 Profit Factor:0.00 Total Net Profit:1248.09

BackTest : USDJPY on H1

From 2009-11-01 to 2009-11-30 Profit Factor:2.26 Total Net Profit:6000.87

Request Backtest for SimpleGrail


From : (yyyy/mm/dd) To: (yyyy/mm/dd)

Pair: Period: