gurooex01

//+------------------------------------------------------------------+
//|                                                    GurooEx01.mq5 |
//|     Copyright © 2010, Marketing Dreams Ltd. All Rights Reserved. |
//|                     http://community.trading-gurus.com/threads/9 |
//|                                                                  |
//| GuruTrader™ example 1                                            |
//| Object Oriented MQL5 Version 1.0                                 |
//|                                                                  |
//| A quick port of our MQL4 robot example 1 to MQL5 for use with    |
//| the public beta test version of MetaTrader 5. It is written      |
//| using MetaQuotes object oriented framework for MQL5.             |
//|                                                                  |
//| Uses a random number generator to simulate tossing a coin.       |
//| It can be amazingly profitable given that it uses random entries!|                                                                  |
//|                                                                  |
//| Wealth Warning! This expert is for educational purposes only.    |
//| It should NEVER be used on a live account. Past performance is   |
//| in no way indicative of future results!                          |
//+------------------------------------------------------------------+
#property copyright   "Copyright © 2010, Marketing Dreams Ltd."
#property link        "http://community.trading-gurus.com/threads/9"
#property version     "1.00"
#property description "An example of an OOP random entry system"

//---- include object oriented framework
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\AccountInfo.mqh>
#include <Indicators\Indicators.mqh>

//---- input parameters
input  int     Magic = 12345;
input  int     Slippage=30;
input  int     ProfitTarget=1000;  
input  int     StopLoss=10000;  
input  double  Lots=0.1;
input  bool    ReallyRandom=true;

//+------------------------------------------------------------------+
//| MA crossover example expert class                                |
//+------------------------------------------------------------------+
class CGuruEx01
{
private:
   int               Dig;
   double            Points;
   bool              Initialized;
   bool              Running;
   ulong             OrderNumber;
   double            GetSize();

protected:
   string            m_Pair;                    // Currency pair to trade 
   CTrade            m_Trade;                   // Trading object
   CSymbolInfo       m_Symbol;                  // Symbol info object
   CPositionInfo     m_Position;                // Position info object
   void              InitSystem();
   bool              CheckEntry();
   bool              CheckExit();

public:
                     CGuruEx01();               // Constructor
                    ~CGuruEx01() { Deinit(); }  // Destructor
   bool              Init(string Pair);
   void              Deinit();
   bool              Validated();
   bool              Execute();
};

CGuruEx01 GuruEx01;

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CGuruEx01::CGuruEx01()
{
   Initialized = false;
}

//+------------------------------------------------------------------+
//| Performs system initialisation                                   |
//+------------------------------------------------------------------+
bool CGuruEx01::Init(string Pair)
{
   m_Pair = Pair;
   m_Symbol.Name(m_Pair);                // Symbol
   m_Trade.SetExpertMagicNumber(Magic);  // Magic number
   
   Dig = m_Symbol.Digits();
   Points = m_Symbol.Point();
   m_Trade.SetDeviationInPoints(Slippage);
   
   Print("Digits = ", Dig, ", Points = ", DoubleToString(Points, Dig));

   if (ReallyRandom)
      MathSrand(TimeLocal()); // Initialize random number generator
   else
      MathSrand(1);           // Same every time
      
   Initialized = true;
   
   return(true);
}
         
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
CGuruEx01::Deinit()
{
   Initialized = false;
   
   Print("DeInitialized OK");
}

//+------------------------------------------------------------------+
//| Returns trade size based on money management system (if any!)    |
//+------------------------------------------------------------------+
double CGuruEx01::GetSize()
{
   return (Lots);
}

//+------------------------------------------------------------------+
//| Checks if everything initialized successfully                    |
//+------------------------------------------------------------------+
bool CGuruEx01::Validated()
{
   return (Initialized);
}

//+------------------------------------------------------------------+
//| Performs system reinitialisation                                 |
//+------------------------------------------------------------------+
void CGuruEx01::InitSystem()
{
   Running = false;
   Initialized = true;
}
         
//+------------------------------------------------------------------+
//| Performs system logic. Called on every tick                      |
//+------------------------------------------------------------------+
bool CGuruEx01::Execute()   
{
   if (Running) {                   // Are we in a trade at the moment?
      if (CheckExit() > 0) {        // Yes - Last trade complete?
         Initialized = false;       // Yes - Indicate we need to reinitialise
         InitSystem();              //  and start all over again!
      }
   }
   else {
      if (CheckEntry() > 0) {       // Entered a trade?
         Running = true;            // Yes - Indicate that we're in a trade
      }   
   }
   return(true);
}

//+------------------------------------------------------------------+
//| Checks for entry to a trade                                      |
//+------------------------------------------------------------------+
bool CGuruEx01::CheckEntry()
{
   int CoinToss;
   
   m_Symbol.RefreshRates();
   CoinToss = MathRand();
   Print("CoinToss = ", CoinToss, ", Bid = ", m_Symbol.Bid(), ", Ask = ", m_Symbol.Ask());
   
   if (CoinToss < 16384 ) {               // Coin came up heads, so GO LONG!
      if (m_Trade.PositionOpen(Symbol(), ORDER_TYPE_BUY, GetSize(), m_Symbol.Ask(),
                               m_Symbol.Bid() - (Points * StopLoss),
                               m_Symbol.Ask() + (Points * ProfitTarget))) {
         OrderNumber = m_Trade.ResultOrder();
         Print("Entered LONG at ", TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
         return(true);
      }
      else {
         OrderNumber = 0;
      }   
   }
   else  {                                // Coin came up tails, so GO SHORT!
      if (m_Trade.PositionOpen(Symbol(), ORDER_TYPE_SELL, GetSize(), m_Symbol.Bid(),
                               m_Symbol.Ask() + (Points * StopLoss),
                               m_Symbol.Bid() - (Points * ProfitTarget))) {
         OrderNumber = m_Trade.ResultOrder();
         Print("Entered SHORT at ", TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
         return(true);
      }   
      else {
         OrderNumber = 0;
      }   
   }

   return(false);
}

//+------------------------------------------------------------------+
//| Checks for exit from a trade                                     |
//+------------------------------------------------------------------+
bool CGuruEx01::CheckExit()
{
   double PositionSize;
   
   if (m_Position.Select(m_Pair) != true) {
      Print("Position flat at ", TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
      return(true);
   }
   else {
      m_Position.InfoDouble(POSITION_VOLUME, PositionSize);
      if (PositionSize <= 0) {
         Print("Position closed at ", TimeToString(TimeCurrent(), TIME_DATE | TIME_SECONDS));
         return(true);
      }
      else {
         return(false);
      }
   }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   if (AccountInfoInteger(ACCOUNT_TRADE_MODE) == ACCOUNT_TRADE_MODE_REAL) {
      MessageBox("Wealth Warning! This expert is for educational purposes only." +
            " It should NEVER be used on a live account." +
            " Past performance is in no way indicative of future results!");
      Print("Initialization Failure");
      return(-1);
   }

   if (!GuruEx01.Init(Symbol())) {
      GuruEx01.Deinit();
      return(-1);
   }

   Print("Initialized OK");
   
   return(0);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   GuruEx01.Deinit();
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
   if (!GuruEx01.Validated()) {
      return;
   }

   GuruEx01.Execute();   
}