TrueHedge1





//+------------------------------------------------------------------+
//|                                                    TrueHedge.mq4 |
//|                                               by Hartono Setiono |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2007,  Hartono Setiono"
#property link      "http://www.mitrakom.com"
#include <stdlib.mqh>
#include <stderror.mqh>
extern double LotSize=2;
extern int    Slippage=3;
extern double StopLoss=0;
extern double TakeProfit=100;
extern int    GMTShift=0;
extern int    OpenPosHandler=0; 
extern int    MinInitialOrderProfit=500;

/* 
OpenPosHandler:
0:never close till positif at the end of the day
1:check everytime for takeProfit Level
2:wait till next end of the day and close
*/
int           ticket;
int           OpenBuyOrders = 0;
int           OpenSellOrders = 0;
int           LastMN=0; //Last Magic Number
int           TodayMN=0; //Today Magic Number;
int           maxloop=25; // maximum number of attempts to handle errors
int           MNFactor=100000;
int           MagicNumber=123;
string        EAName="TrueHedge 0.1";


//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
  switch (OpenPosHandler)
  {
    case 0:
    case 1:
    case 2: break;
    default:OpenPosHandler=0;
  }
  return(0);
}


//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
  return(0);
}

//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
  TodayMN = MagicNumber*MNFactor+ (Year() % 100)*10000 + Month()*100 + Day();
  if(DayOfWeek()==0 || DayOfWeek()==6) return(0);
  if(Hour()+GMTShift==23 && Minute()==00) 
  {
    if (OpenPosHandler==0) HandleOpenPositions(3);
    if (OpenPosHandler==2) HandleOpenPositions(4);
    HandleOpenPositions(2);
  }
  
  LastMN=GetLastMN();
    
  if(Hour()+GMTShift==0 && Minute()==0 && LastMN==0) 
  {
    OpenOrder(OP_BUY,LotSize,Ask,Slippage,0,0,EAName,TodayMN,0,Blue);
    OpenOrder(OP_SELL,LotSize,Bid,Slippage,0,0,EAName,TodayMN,0,Red);
    LastMN=TodayMN;
  }
  if (OpenPosHandler==1) HandleOpenPositions(1);
  return(0);
}
//+------------------------------------------------------------------+

int HandleOpenPositions(int id)
{
   int cnt, OrderMN;
   double lotsi;
   
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      lotsi=OrderLots();
      OrderMN=OrderMagicNumber();

      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMN/MNFactor != MagicNumber)  continue;
      
      if (id==1)
      if (OrderMN != LastMN)
      {
        if (MNProfit(OrderMN)>TakeProfit)
        {
          CloseLongs(OrderMN);
          CloseShorts(OrderMN);
        }
      }

      if (id==2)
      {
        if (OrderMN==LastMN)
        {
          if (OrderType() == OP_BUY && OrderProfit()>MinInitialOrderProfit)
          {
            OrderClose(OrderTicket(),lotsi,Bid,Slippage,Blue);
            CloseShorts(OrderMN, lotsi/2);
          }
      
          if (OrderType() == OP_SELL && OrderProfit()>MinInitialOrderProfit)
          {
            OrderClose(OrderTicket(),lotsi,Ask,Slippage,Red);
            CloseLongs(OrderMN, lotsi/2);
          }
        }
      }

      if (id==3)
      if (OrderMN != LastMN)
      {
        if (MNProfit(OrderMN)>TakeProfit)
        {
          CloseLongs(OrderMN);
          CloseShorts(OrderMN);
        }
      }
      if (id==4)
      if (OrderMN != LastMN)
      {
        CloseLongs(OrderMN);
        CloseShorts(OrderMN);
      }
   }
   return(0);
}

double MNProfit(int MagicNumber)
{
   int cnt;
   double profit=0;
   
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMagicNumber() != MagicNumber)  continue;
      profit=profit+OrderProfit();
   }
   return(profit);
}

double MNDirection(int MagicNumber)
{
   int cnt;
   double lotsi=0;
   
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      if ( OrderSymbol() != Symbol()) continue;
      if ( OrderMagicNumber() != MagicNumber)  continue;
      if ( OrderType()==OP_BUY ) lotsi=lotsi+OrderLots();
      if ( OrderType()==OP_SELL ) lotsi=lotsi-OrderLots();
   }
   return(lotsi);
}

int GetLastMN()
{
   int cnt, OrderMN, LastMN=0;
   double lotsi;
   for(cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect (cnt, SELECT_BY_POS, MODE_TRADES);
      OrderMN=OrderMagicNumber();
      if ( OrderSymbol() != Symbol()) continue;
      if (OrderMN/MNFactor != MagicNumber)  continue;

      lotsi=MNDirection(OrderMN);
      if (lotsi==0) { LastMN=OrderMN; break;}
   }
   return(LastMN);
}

int OpenOrder(int pType,double pLots,double pLevel,int sp, int sl, int tp,string pComment,int pMagic,datetime pExpiration,color pColor)
{
  int ticket=0;
  int err=0;
  int c = 0;
  int NumberOfTries = 10;
  switch (pType)
  {
      case OP_BUY:
         for(c = 0 ; c < NumberOfTries ; c++)
         {  
            RefreshRates();
            ticket=OrderSend(Symbol(),OP_BUY,pLots,Ask,sp,StopLong(Bid,sl),TakeLong(Bid,tp),pComment,pMagic,pExpiration,pColor);
            if (ticket > 0) break;
            err=GetLastError();
            if(err==0)
            { 
               break;
            }
            else
            {
               if(err==4 || err==137 ||err==146 || err==136) //Busy errors
               {
                  Sleep(5000);
                  continue;
               }
               else //normal error
               {
                  Print("Error Code= ", err);
                  break;
               }  
            }
         } 
         break;
      case OP_SELL:
         for(c = 0 ; c < NumberOfTries ; c++)
         {
            RefreshRates();
            ticket=OrderSend(Symbol(),OP_SELL,pLots,Bid,sp,StopShort(Ask,sl),TakeShort(Ask,tp),pComment,pMagic,pExpiration,pColor);
            if (ticket > 0) break;
            err=GetLastError();
            if(err==0)
            { 
               break;
            }
            else
            {
               if(err==4 || err==137 ||err==146 || err==136) //Busy errors
               {
                  Sleep(5000);
                  continue;
               }
               else //normal error
               {
                  Print("Error Code= ", err);
                  break;
               }  
            }
         } 
         break;
  } 
  
  return(ticket);
}  



void CloseLongs(int MagicNumber, double clots=0)
{
 int trade;
 double olots;
 
 for(trade=OrdersTotal()-1;trade>=0;trade--)
 {
  if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES)==false) continue;
  if(OrderSymbol()!=Symbol()||OrderMagicNumber()!=MagicNumber) continue;
  if(OrderType()!=OP_BUY) continue;
   
  olots=OrderLots();
  if (clots==0) clots=olots;
  OrderClose(OrderTicket(),clots,Bid,Slippage,Blue);

  if(olots!=clots && StopLoss !=0)
  ModifyStopLoss(OrderTicket(),StopLong(Bid,StopLoss));
 }//for
}

void CloseShorts(int MagicNumber, double clots=0)
{
 int trade;
 double olots;
 for(trade=OrdersTotal()-1;trade>=0;trade--)
 {
  if(OrderSelect(trade,SELECT_BY_POS,MODE_TRADES)==false) continue;
  if(OrderSymbol()!=Symbol()||OrderMagicNumber()!=MagicNumber) continue;
  if(OrderType()!=OP_SELL) continue;
  
  olots=OrderLots();
  if (clots==0) clots=olots; 
  OrderClose(OrderTicket(),clots,Ask,Slippage,Red);

  if(olots!=clots && StopLoss !=0)
  ModifyStopLoss(OrderTicket(),StopShort(Ask,StopLoss));
 }//for
}

double StopLong(double price,int stop)
{
 if(stop==0)
  return(0);
 else
  return(price-(stop*Point));
}

double StopShort(double price,int stop)
{
 if(stop==0)
  return(0);
 else
  return(price+(stop*Point));
}

double TakeLong(double price,int take)
{
 if(take==0)
  return(0);
 else
  return(price+(take*Point));
}

double TakeShort(double price,int take)
{
 if(take==0)
  return(0);
 else
  return(price-(take*Point));
}


int HandleTrailingStop(int type, int ticket, double open_price, double cur_sl, int TrailingStopType, int TrailingStop)
{
	double pt, TS = 0, myAsk, myBid;


	if (type == OP_BUY)
	{
		myBid = MarketInfo(Symbol(),MODE_BID);
		switch (TrailingStopType)
		{
			case 1: 
				pt = Point * StopLoss;
				if (myBid - cur_sl > pt) 
					ModifyStopLoss(ticket, myBid - pt);
				break;
				
			case 2: 
				pt = Point * TrailingStop;
				if (myBid - open_price > pt && (cur_sl < myBid - pt || cur_sl == 0))
					ModifyStopLoss(ticket, myBid - pt);
				break;

		}
		return(0);
	}


	else if (type ==  OP_SELL)
	{
		myAsk = MarketInfo(Symbol(),MODE_ASK);
		switch (TrailingStopType)
		{
			case 1: 
				pt = Point * StopLoss;
				if (cur_sl - myAsk > pt) 
					ModifyStopLoss(ticket, myAsk+pt);
				break;
				
			case 2: 
				pt = Point * TrailingStop;
				if (open_price - myAsk > pt && (cur_sl > myAsk + pt || cur_sl == 0))
					ModifyStopLoss(ticket, myAsk+pt);
				break;
				
		 }
	 }
	 return(0);
}

int ModifyStopLoss(int ticket, double stoploss)
{
    int Cnt, digits, err;
    string symbol;
    double myStopLoss;
    
    OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES);
    symbol = OrderSymbol();
    digits = MarketInfo(symbol,MODE_DIGITS);
    if (digits > 0)
    {
			 myStopLoss = NormalizeDouble(stoploss,digits);
    }
    Cnt=0;
    while (Cnt < 3)
    {
       if (OrderModify(ticket,OrderOpenPrice(),myStopLoss,OrderTakeProfit(),0,Aqua))
       {
         Cnt = 3;
       }
       else
       {
          err=GetLastError();
          Print(Cnt," Error modifying order : (", err , ") " + ErrorDescription(err));
         if (err>0) Cnt++;
       }
    }
}





Sample





Analysis



Market Information Used:



Indicator Curves created:


Indicators Used:



Custom Indicators Used:

Order Management characteristics:
Checks for the total of open orders

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

Other Features:

BackTest : EURUSD on H1

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

BackTest : EURUSD on H1

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

BackTest : EURUSD on H1

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

BackTest : GBPUSD on H1

From 2010-01-01 to 2010-02-27 Profit Factor:0.98 Total Net Profit:-3716.80

Request Backtest for TrueHedge1


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

Pair: Period: