SimpleDailyRangeBreakExpert_v1.23

Author: Copyright � 2007, TrendLaboratory
Profit factor:
0.97
Orders Execution
Checks for the total of open ordersIt Closes Orders by itself It can change open orders parameters, due to possible stepping strategyIt automatically opens orders when conditions are reached
6 Views
0 Downloads
0 Favorites
SimpleDailyRangeBreakExpert_v1.23
//+------------------------------------------------------------------+
//|                            SimpleDailyRangeBreakExpert_v1.23.mq4 |
//|                                Copyright © 2007, TrendLaboratory |
//|            http://finance.groups.yahoo.com/group/TrendLaboratory |
//|                                   E-mail: igorad2003@yahoo.co.uk |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007, TrendLaboratory"
#property link      "http://finance.groups.yahoo.com/group/TrendLaboratory"

#include <stdlib.mqh>

//---- input parameters
extern string     Expert_Name = "---- SimpleDailyRangeBreakExpert_v1.23 ----";

extern int        Magic          =2009;
extern int        Slippage       =     6;

extern string     Main_Parameters = " Trade Volume & Trade Method";
extern double     Lots           =   1;
extern double     TrailingStop   =     0;  // Trailing Stop Switch   
extern double     TakeProfit     =     0;  // 
extern int        TimeShift      =     9;   

extern string     Data = " Input Data ";
extern double     BuyPercent     =    20;  // Percent from Daily Range for BUY 	
extern double     SellPercent    =    30;  // Percent from Daily Range for SELL
extern double     StopPercent    =    190;  // Percent from Daily Range for StopLoss
extern int        TradePeriod    =     6;  // Max days in trade 
extern double     BreakEven      =     0;  // BreakEven Level in pips
extern double     BreakEvenGap   =     0;  // Pips when BreakEven will be reached

extern string     Trade   =  " Trade Days of Week";
extern int        Monday         =     1;  // Day of the Week for Trade
extern int        Tuesday        =     1;
extern int        Wednesday      =     1;
extern int        Thursday       =     1;
extern int        Friday         =     1;

extern string     MM_Parameters = " MoneyManagement by L.Williams ";
extern bool       MM             = true;  // ÌÌ Switch
extern double     MMRisk         =  0.15;  // Risk Factor
extern double     LossMax        =  3200;  // Maximum Loss by 1 Lot


int      i,cnt=0, ticket, mode=0, digit=0, wenum=0,OrderOpenDay, DaysInTrade, Kz;
double   high=0,low=0, close=0, open=0, range=0, spread=0, Profit=0;
double   smin=0, smax=0, BuyStop=0, SellStop=0, Lotsi=0, rates_h1[][6];
bool     BuyInTrade=false, SellInTrade=false;
datetime StartTime, prevwe=0, Today, PrevDay;
//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//---- 

//----
   return(0);
  }
// ---- Money Management
double MoneyManagement ( bool flag, double Lots, double risk, double maxloss)
{
   double Lotsi=Lots;
	    
   if ( flag ) Lotsi=NormalizeDouble(Lots*AccountFreeMargin()*risk/maxloss,1);   
     
   if (Lotsi<0.1) Lotsi=0.1;  
   return(Lotsi);
}   

// Closing of Pending Orders      
void PendOrdDel()
{
   int total=OrdersTotal();
   for (int cnt=total-1;cnt>=0;cnt--)
   { 
   OrderSelect(cnt, SELECT_BY_POS,MODE_TRADES);   
      
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic  )     
      {
      int mode=OrderType();
        
      bool result = false;
         switch(mode)
         {
         case OP_BUYSTOP   :  {
                              result = OrderDelete( OrderTicket() );
                                 if(!result)
                                 {
                                 Print("BUYSTOP: OrderDelete failed with error #",GetLastError());
                                 return(0);
                                 }
                              break;
                              }
          
         case OP_SELLSTOP  :  {
                              result = OrderDelete( OrderTicket() );  
                                 if(!result)
                                 {
                                 Print("SELLSTOP: OrderDelete failed with error #",GetLastError());
                                 return(0);
                                 }
                              break;
                              }
                                
         }
      }
   } 
}    

// 

void CloseOrdbyTime()
{
   int total=OrdersTotal();
    
   for (cnt=0;cnt<total;cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   mode=OrderType();
      if ( mode <= OP_SELL && OrderSymbol()==Symbol() && OrderMagicNumber()==Magic)
      { 
         if (DaysInTrade >= TradePeriod || OrderProfit()>0)
         {
            if (mode==OP_BUY )
			   OrderClose(OrderTicket(),OrderLots(),Bid,Slippage,Yellow);
			   if (mode==OP_SELL)
			   OrderClose(OrderTicket(),OrderLots(),Ask,Slippage,White);
         }
      }
   }
}       
 
// ---- 
void TrailStop()
{
   for (cnt=0;cnt<OrdersTotal();cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   int mode=OrderType();    
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic) 
      {
         if (mode==OP_BUY) 
         {
			BuyStop = NormalizeDouble(Bid - TrailingStop*Point, Digits);
			   if( OrderOpenPrice() < BuyStop || OrderStopLoss() == 0 ) 
            {   
			      if ( BuyStop > NormalizeDouble(OrderStopLoss(),Digits)) 
			      {
			      bool result = OrderModify(OrderTicket(),OrderOpenPrice(),
			                                BuyStop,
			                                OrderTakeProfit(),0,LightGreen);
			         if( !result )
                  {
                  Print("BUY: OrderModify failed with error #",GetLastError());
                  }
			      return(0);
               }            
            }
         }   
// - SELL Orders          
         if (mode==OP_SELL)
         {
         SellStop = NormalizeDouble(Ask + Point * TrailingStop,Digits);   
            if( OrderOpenPrice() > SellStop) 
            {
               if( NormalizeDouble(OrderStopLoss(), Digits) > SellStop || OrderStopLoss() == 0 ) 
               {
               result = OrderModify(OrderTicket(), OrderOpenPrice(),
                           SellStop,
			                  OrderTakeProfit(),0,DarkOrange);
                  if( !result )
                  {
                  Print("SELL: OrderModify failed with error #",GetLastError());
                  }
               return(0);
               }   
   			}	    
         }
      }
   }     
}

void SellOrdOpen()
{		     
   double SellPrice = open - range*SellPercent/100.0 - spread;
	
	if (StopPercent > 0) SellStop=SellPrice + StopPercent*range/100.0; else SellStop=0;
   if (TakeProfit > 0) Profit = SellPrice - TakeProfit*Point; else Profit=0;
	  
	ticket = OrderSend(Symbol(),OP_SELLSTOP,Lotsi,
	                   NormalizeDouble(SellPrice,digit),
	                   Slippage,
	                   NormalizeDouble(SellStop,digit),
	                   Profit,"v1.23",Magic,0,Red);
    

   OrderOpenDay  = DayOfWeek();   
   SellInTrade=false;            
       
   if(ticket<0)
   {
   Print("Sell: OrderSend failed with error #",GetLastError());
   return(0);
   }
}

void BuyOrdOpen()
{		     
   double BuyPrice = open + range*BuyPercent/100.0  + spread;
	if (StopPercent > 0) BuyStop = BuyPrice - StopPercent*range/100.0; else BuyStop=0;
   if (TakeProfit > 0) Profit = BuyPrice + TakeProfit*Point; else Profit=0;
		
	ticket = OrderSend(Symbol(),OP_BUYSTOP ,Lotsi,
	                   NormalizeDouble(BuyPrice ,digit),
	                   Slippage,
	                   NormalizeDouble(BuyStop ,digit),
	                   Profit,"v1.23",Magic,0,Blue);
           
   OrderOpenDay  = DayOfWeek();
   BuyInTrade=false;            
       
   if(ticket<0)
   {
   Print("Buy: OrderSend failed with error #",GetLastError());
   return(0);
   }
}      

void ExtraOrdDel()
{
   int total = OrdersTotal();
   for (cnt=0;cnt<total;cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   mode=OrderType();
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic )     
      {
      if (mode==OP_BUY  && !BuyInTrade ) BuyInTrade =true;
      if (mode==OP_SELL && !SellInTrade) SellInTrade=true;
            
         if (mode == OP_SELLSTOP && BuyInTrade )
         { 
         bool result = OrderDelete(OrderTicket()); 
         SellInTrade=false; 
            if(!result)
            {
            Print("ExtraSELL: OrderDelete failed with error #",GetLastError());
            return(0);
            } 
         }
         if (mode == OP_BUYSTOP && SellInTrade )
         { 
         result = OrderDelete(OrderTicket()); 
         BuyInTrade=false; 
            if(!result)
            {
            Print("ExtraBUY: OrderDelete failed with error #",GetLastError());
            return(0);
            }  
         }
      }
   }        
}

// ---- Scan Trades
int ScanTrades()
{   
   int total = OrdersTotal();
   int numords = 0;
      
   for(cnt=0; cnt<total; cnt++) 
   {        
   OrderSelect(cnt, SELECT_BY_POS);            
   if(OrderSymbol() == Symbol() && OrderType()>=OP_BUY && OrderMagicNumber() == Magic) 
   numords++;
   }
   return(numords);
}

datetime OrderOpenDate()
{
   int total = OrdersTotal();
   datetime date;
   for(cnt=0; cnt<total; cnt++) 
   {        
   OrderSelect(cnt, SELECT_BY_POS);            
   if(OrderSymbol() == Symbol() && OrderType()>=OP_BUY && OrderMagicNumber() == Magic) 
   date = StrToTime(TimeToStr(OrderOpenTime(),TIME_DATE));
   }
   return(date);
}  

void BreakEvenStop()
{        
   for (cnt=0;cnt<OrdersTotal();cnt++)
   { 
   OrderSelect(cnt, SELECT_BY_POS);   
   int mode=OrderType();    
      if ( OrderSymbol()==Symbol() && OrderMagicNumber()==Magic) 
      {
         if (mode==OP_BUY)
         {
			   if (Bid-OrderOpenPrice() > BreakEven*Point) 
			   {  
			   Kz = MathFloor((Bid-OrderOpenPrice())/(BreakEven*Point));   
			      if (Bid-OrderOpenPrice() > Kz*BreakEven*Point) 
			      {
			      BuyStop=OrderOpenPrice()+((Kz-1)*BreakEven+BreakEvenGap)*Point;
			      if ( OrderStopLoss() == 0 ) double StopLoss = OrderOpenPrice(); else StopLoss = OrderStopLoss();   
			         if (BuyStop > StopLoss )
			         {
			         OrderModify(OrderTicket(),OrderOpenPrice(),
			                     NormalizeDouble(BuyStop, digit),
			                     OrderTakeProfit(),0,LightBlue);
			            
			          return(0);
			         }
			      }
            }
         }               			         
               
         if (mode==OP_SELL)
         {
            if (OrderOpenPrice()-Ask > BreakEven*Point)
            {
            Kz = MathFloor((OrderOpenPrice()-Ask)/(BreakEven*Point)); 
               if (OrderOpenPrice()-Ask > Kz*BreakEven*Point) 
			      {
			      SellStop=OrderOpenPrice()-((Kz-1)*BreakEven+BreakEvenGap)*Point;
			      if ( OrderStopLoss() == 0 ) StopLoss = OrderOpenPrice(); else StopLoss = OrderStopLoss();   
			         if ( SellStop < StopLoss )
			         {
			         OrderModify(OrderTicket(),OrderOpenPrice(),
			                     NormalizeDouble(SellStop, digit),
			                     OrderTakeProfit(),0,Orange);
			            
			         return(0);
			         }
               }
		      }
         }
      }   
   } 
}	                    
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
   if(Bars < 1) {Print("Not enough bars for this strategy"); return(0);}
   if (BreakEven >= 0 && BreakEven < BreakEvenGap) return(0);
   
   string   TimeTrade = "00:00";
   StartTime  = StrToTime(TimeTrade) + TimeShift*3600;
  
   if(CurTime() >= StartTime && CurTime() <= StartTime+3600)
   {
      if ( OrderOpenDate() < StrToTime(TimeToStr( StartTime,TIME_DATE))) 
      { 
      if( ScanTrades()>0 && !BuyInTrade && !SellInTrade) PendOrdDel(); 
      Today = StrToTime(TimeToStr( StartTime,TIME_DATE));
      if (Today != PrevDay ) 
      { DaysInTrade = DaysInTrade+1; 
      //Print(" Days=",DaysInTrade,"Today=",TimeToStr(Today,TIME_DATE),"PrevDay=", TimeToStr(PrevDay,TIME_DATE)) ;
      }
      
      if( TradePeriod > 0 )CloseOrdbyTime(); 
      }
      
      if(ScanTrades()<1 && Today != PrevDay )
      {
      
      spread= MarketInfo(Symbol(),MODE_SPREAD)*Point;
      digit  = MarketInfo(Symbol(),MODE_DIGITS);
      Lotsi = MoneyManagement ( MM, Lots, MMRisk, LossMax);
      //if (TrailingStop > 0) InitialStop=true; 
   
      ArrayCopyRates(rates_h1, Symbol(), PERIOD_H1);
      open = rates_h1[0][1];
      high=0; low=10000000;
      for (i=24;i>=1;i--)
      {
      high = MathMax( high, rates_h1[i][3]);
      low  = MathMin( low , rates_h1[i][2]);      
      }   
       
      range =(high-low); 
         
      if ( Monday   == 1 ) if(DayOfWeek()==1){BuyOrdOpen(); SellOrdOpen();}
      if ( Tuesday  == 1 ) if(DayOfWeek()==2){BuyOrdOpen(); SellOrdOpen();}
      if ( Wednesday== 1 ) if(DayOfWeek()==3){BuyOrdOpen(); SellOrdOpen();} 
      if ( Thursday == 1 ) if(DayOfWeek()==4){BuyOrdOpen(); SellOrdOpen();} 
      if ( Friday   == 1 ) if(DayOfWeek()==5){BuyOrdOpen(); SellOrdOpen();}
      DaysInTrade = 0;
      }
      
    
   }
   ExtraOrdDel();
   if (BreakEven > 0) BreakEvenStop();
   if (TrailingStop > 0 ) TrailStop(); 
 
   PrevDay=Today;
 return(0);
}//int start
//+------------------------------------------------------------------+





Profitability Reports

USD/CHF Jul 2025 - Sep 2025
0.48
Total Trades 22
Won Trades 13
Lost trades 9
Win Rate 59.09 %
Expected payoff -74.36
Gross Profit 1534.18
Gross Loss -3170.03
Total Net Profit -1635.85
-100%
-50%
0%
50%
100%
NZD/USD Jul 2025 - Sep 2025
0.61
Total Trades 25
Won Trades 17
Lost trades 8
Win Rate 68.00 %
Expected payoff -34.32
Gross Profit 1365.60
Gross Loss -2223.60
Total Net Profit -858.00
-100%
-50%
0%
50%
100%
GBP/USD Jul 2025 - Sep 2025
0.85
Total Trades 32
Won Trades 24
Lost trades 8
Win Rate 75.00 %
Expected payoff -21.64
Gross Profit 3845.90
Gross Loss -4538.30
Total Net Profit -692.40
-100%
-50%
0%
50%
100%
GBP/CAD Jul 2025 - Sep 2025
1.23
Total Trades 27
Won Trades 22
Lost trades 5
Win Rate 81.48 %
Expected payoff 19.41
Gross Profit 2814.17
Gross Loss -2290.00
Total Net Profit 524.17
-100%
-50%
0%
50%
100%
GBP/AUD Jul 2025 - Sep 2025
0.66
Total Trades 24
Won Trades 20
Lost trades 4
Win Rate 83.33 %
Expected payoff -28.08
Gross Profit 1309.43
Gross Loss -1983.28
Total Net Profit -673.85
-100%
-50%
0%
50%
100%
EUR/USD Jul 2025 - Sep 2025
0.71
Total Trades 27
Won Trades 20
Lost trades 7
Win Rate 74.07 %
Expected payoff -30.51
Gross Profit 2024.50
Gross Loss -2848.20
Total Net Profit -823.70
-100%
-50%
0%
50%
100%
USD/CHF Jan 2025 - Jul 2025
1.49
Total Trades 58
Won Trades 47
Lost trades 11
Win Rate 81.03 %
Expected payoff 53.48
Gross Profit 9426.63
Gross Loss -6324.69
Total Net Profit 3101.94
-100%
-50%
0%
50%
100%
USD/CAD Jan 2025 - Jul 2025
0.57
Total Trades 58
Won Trades 42
Lost trades 16
Win Rate 72.41 %
Expected payoff -51.02
Gross Profit 4002.10
Gross Loss -6961.01
Total Net Profit -2958.91
-100%
-50%
0%
50%
100%
NZD/USD Jan 2025 - Jul 2025
0.91
Total Trades 54
Won Trades 42
Lost trades 12
Win Rate 77.78 %
Expected payoff -9.74
Gross Profit 5497.20
Gross Loss -6023.00
Total Net Profit -525.80
-100%
-50%
0%
50%
100%
GBP/USD Jan 2025 - Jul 2025
0.98
Total Trades 61
Won Trades 50
Lost trades 11
Win Rate 81.97 %
Expected payoff -3.47
Gross Profit 8476.00
Gross Loss -8687.50
Total Net Profit -211.50
-100%
-50%
0%
50%
100%

Comments