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;
                           }
                  }

               }
             }
          }
        }
    }