//+------------------------------------------------------------------+

//|                                      RiskGuard_ORB_Example.mq5   |

//|                                                                  |

//| Example indicator for RiskGuard Strategy Mode - Config. 2        |

//|                                                                  |

//| This indicator does NOT open trades directly.                    |

//| It only sends market or pending signals to RiskGuard using the   |

//| official RiskGuard Config. 2 protocol.                           |

//|                                                                  |

//| RiskGuard manages the order, lot size, risk, Stop Loss,           |

//| Take Profit, Break Even, partial profits, trailing stop,          |

//| daily loss limits, Quantum and all other trading operations.      |

//+------------------------------------------------------------------+

#property strict

#property indicator_chart_window

#property indicator_plots 0

 

 

//+------------------------------------------------------------------+

//| Strategy inputs                                                  |

//+------------------------------------------------------------------+

input int RangeStartHour   = 6;   // ORB range start hour

input int RangeStartMinute = 0;   // ORB range start minute

 

input int RangeEndHour     = 11;  // ORB range end hour

input int RangeEndMinute   = 0;   // ORB range end minute

 

input ENUM_TIMEFRAMES BreakoutTimeframe = PERIOD_M1; // Breakout detection timeframe

 

input double EntryPercent = 0.0;  // 0 = market, 50 = pending at 50% of the box

input double RiskReward   = 2.0;  // Take Profit expressed as Risk:Reward ratio

 

input color BoxColor = clrDodgerBlue; // ORB box color

 

 

//+------------------------------------------------------------------+

//| Internal variables                                               |

//+------------------------------------------------------------------+

datetime IndicatorLoadTime = 0;

datetime LastBreakoutBarTime = 0;

 

bool ActivityDetectedAfterSignal = false;

bool ShowGraphics = true;

 

 

//+------------------------------------------------------------------+

//| Official RiskGuard signal function - Config. 2                   |

//|                                                                  |

//| pendingPrice = 0.0  -> market order                              |

//| pendingPrice > 0.0  -> pending order                             |

//|                                                                  |

//| DO NOT MODIFY THIS FUNCTION.                                     |

//| This function must remain identical in all RiskGuard-compatible  |

//| indicators.                                                      |

//+------------------------------------------------------------------+

void SendRiskGuardConfig2Signal(double stopPrice,

                         double takePrice,

                         double pendingPrice = 0.0)

  {

   //--- Always delete old RiskGuard variables first

   GlobalVariableDel("RG_Strategy_Config2_Symbol_" + _Symbol);

   GlobalVariableDel("RG_Strategy_Config2_Stop_"   + _Symbol);

   GlobalVariableDel("RG_Strategy_Config2_Take_"   + _Symbol);

   GlobalVariableDel("RG_Strategy_Config2_Price_"  + _Symbol);

 

   //--- Normalize prices

   stopPrice = NormalizeDouble(stopPrice, _Digits);

   takePrice = NormalizeDouble(takePrice, _Digits);

 

   if(pendingPrice > 0.0)

      pendingPrice = NormalizeDouble(pendingPrice, _Digits);

 

   bool isPending = (pendingPrice > 0.0);

 

   //--- Create variables in the correct order

   GlobalVariableSet("RG_Strategy_Config2_Stop_" + _Symbol, stopPrice);

   GlobalVariableSet("RG_Strategy_Config2_Take_" + _Symbol, takePrice);

 

   if(isPending)

      GlobalVariableSet("RG_Strategy_Config2_Price_" + _Symbol, pendingPrice);

 

   //--- RG_Strategy_Symbol must always be created last

   GlobalVariableSet("RG_Strategy_Config2_Symbol_" + _Symbol, 1);

 

   //--- Log

   if(isPending)

     {

      Print("[", MQLInfoString(MQL_PROGRAM_NAME), "][INDICATOR][SIGNAL] Pending signal variables created",

            " | Symbol=", _Symbol,

            " | Stop=", DoubleToString(stopPrice, _Digits),

            " | Take=", DoubleToString(takePrice, _Digits),

            " | Price=", DoubleToString(pendingPrice, _Digits),

            " | Bid=", DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits),

            " | Ask=", DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_ASK), _Digits));

     }

   else

     {

      Print("[", MQLInfoString(MQL_PROGRAM_NAME), "][INDICATOR][SIGNAL] Market signal variables created",

            " | Symbol=", _Symbol,

            " | Stop=", DoubleToString(stopPrice, _Digits),

            " | Take=", DoubleToString(takePrice, _Digits),

            " | Bid=", DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits),

            " | Ask=", DoubleToString(SymbolInfoDouble(_Symbol, SYMBOL_ASK), _Digits));

     }

  }

 

 

//+------------------------------------------------------------------+

//| Returns a numeric key for the trading day                        |

//+------------------------------------------------------------------+

int DayKey(datetime timeValue)

  {

   MqlDateTime dateTime;

   TimeToStruct(timeValue, dateTime);

 

   return(dateTime.year * 10000 +

          dateTime.mon  * 100 +

          dateTime.day);

  }

 

 

//+------------------------------------------------------------------+

//| Builds today's broker/server time                                |

//+------------------------------------------------------------------+

datetime TodayTime(int hour, int minute)

  {

   MqlDateTime dateTime;

   TimeToStruct(TimeCurrent(), dateTime);

 

   dateTime.hour = hour;

   dateTime.min  = minute;

   dateTime.sec  = 0;

 

   return(StructToTime(dateTime));

  }

 

 

//+------------------------------------------------------------------+

//| Internal Global Variable used for duplicate protection           |

//|                                                                  |

//| This is NOT a RiskGuard trade signal.                            |

//|                                                                  |

//| It remembers that the ORB signal for the current day has already |

//| been sent. It must remain available during timeframe changes,    |

//| input changes, refreshes and indicator reinitializations.         |

//+------------------------------------------------------------------+

string LastSignalGVName()

  {

   return("RiskGuard_ORB_LastSignal_" +

          MQLInfoString(MQL_PROGRAM_NAME) +

          "_" +

          _Symbol);

  }

 

 

//+------------------------------------------------------------------+

//| Checks if today's ORB signal has already been sent               |

//+------------------------------------------------------------------+

bool AlreadySentToday()

  {

   string globalVariableName = LastSignalGVName();

 

   if(!GlobalVariableCheck(globalVariableName))

      return(false);

 

   int savedDay = (int)GlobalVariableGet(globalVariableName);

 

   return(savedDay == DayKey(TimeCurrent()));

  }

 

 

//+------------------------------------------------------------------+

//| Saves today's ORB signal status                                  |

//+------------------------------------------------------------------+

void SaveSignalToday()

  {

   GlobalVariableSet(LastSignalGVName(),

                     (double)DayKey(TimeCurrent()));

  }

 

 

//+------------------------------------------------------------------+

//| Returns today's ORB box name                                     |

//+------------------------------------------------------------------+

string BoxName()

  {

   return("RiskGuard_ORB_Box_" +

          MQLInfoString(MQL_PROGRAM_NAME) +

          "_" +

          _Symbol +

          "_" +

          IntegerToString(DayKey(TimeCurrent())));

  }

 

 

//+------------------------------------------------------------------+

//| Deletes today's ORB box                                          |

//+------------------------------------------------------------------+

void DeleteBox()

  {

   if(!ShowGraphics)

      return;

 

   ObjectDelete(0, BoxName());

  }

 

 

//+------------------------------------------------------------------+

//| Deletes ORB boxes belonging to previous days                     |

//+------------------------------------------------------------------+

void DeleteOldBoxes()

  {

   if(!ShowGraphics)

      return;

 

   string prefix =

      "RiskGuard_ORB_Box_" +

      MQLInfoString(MQL_PROGRAM_NAME) +

      "_" +

      _Symbol +

      "_";

 

   string today = IntegerToString(DayKey(TimeCurrent()));

 

   int totalObjects = ObjectsTotal(0);

 

   for(int i = totalObjects - 1; i >= 0; i--)

     {

      string objectName = ObjectName(0, i);

 

      if(StringFind(objectName, prefix) != 0)

         continue;

 

      if(StringFind(objectName, today) >= 0)

         continue;

 

      ObjectDelete(0, objectName);

     }

  }

 

 

//+------------------------------------------------------------------+

//| Checks RiskGuard Strategy positions and pending orders           |

//|                                                                  |

//| RiskGuard Config. 2 Strategy orders use Magic Number 30032999.   |

//+------------------------------------------------------------------+

bool HasRiskGuardStrategyPositionOrOrder()

  {

   const long strategyMagic = 30032999;

 

   for(int i = PositionsTotal() - 1; i >= 0; i--)

     {

      string positionSymbol = PositionGetSymbol(i);

 

      if(positionSymbol != _Symbol)

         continue;

 

      long positionMagic = PositionGetInteger(POSITION_MAGIC);

 

      if(positionMagic == strategyMagic)

         return(true);

     }

 

   for(int i = OrdersTotal() - 1; i >= 0; i--)

     {

      ulong ticket = OrderGetTicket(i);

 

      if(ticket == 0)

         continue;

 

      string orderSymbol = OrderGetString(ORDER_SYMBOL);

 

      if(orderSymbol != _Symbol)

         continue;

 

      long orderMagic = OrderGetInteger(ORDER_MAGIC);

 

      if(orderMagic == strategyMagic)

         return(true);

     }

 

   return(false);

  }

 

 

//+------------------------------------------------------------------+

//| Calculates today's ORB range                                     |

//+------------------------------------------------------------------+

bool GetOrbRange(double &rangeHigh,

                 double &rangeLow)

  {

   datetime startTime =

      TodayTime(RangeStartHour, RangeStartMinute);

 

   datetime endTime =

      TodayTime(RangeEndHour, RangeEndMinute);

 

   if(endTime <= startTime)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Invalid ORB time range",

            " | Start=",

            TimeToString(startTime, TIME_DATE | TIME_MINUTES),

            " | End=",

            TimeToString(endTime, TIME_DATE | TIME_MINUTES));

 

      return(false);

     }

 

   MqlRates rangeRates[];

   ArraySetAsSeries(rangeRates, false);

 

   int copiedBars =

      CopyRates(_Symbol,

                BreakoutTimeframe,

                startTime,

                endTime,

                rangeRates);

 

   if(copiedBars <= 0)

      return(false);

 

   rangeHigh = rangeRates[0].high;

   rangeLow  = rangeRates[0].low;

 

   for(int i = 1; i < copiedBars; i++)

     {

      if(rangeRates[i].high > rangeHigh)

         rangeHigh = rangeRates[i].high;

 

      if(rangeRates[i].low < rangeLow)

         rangeLow = rangeRates[i].low;

     }

 

   rangeHigh = NormalizeDouble(rangeHigh, _Digits);

   rangeLow  = NormalizeDouble(rangeLow, _Digits);

 

   if(rangeHigh <= rangeLow)

      return(false);

 

   return(true);

  }

 

 

//+------------------------------------------------------------------+

//| Creates or updates today's ORB box                               |

//+------------------------------------------------------------------+

void DrawBox(double rangeHigh,

             double rangeLow)

  {

   if(!ShowGraphics)

      return;

 

   datetime startTime =

      TodayTime(RangeStartHour, RangeStartMinute);

 

   datetime endTime =

      TodayTime(RangeEndHour, RangeEndMinute);

 

   string objectName = BoxName();

 

   if(ObjectFind(0, objectName) < 0)

     {

      if(!ObjectCreate(0,

                       objectName,

                       OBJ_RECTANGLE,

                       0,

                       startTime,

                       rangeHigh,

                       endTime,

                       rangeLow))

        {

         Print("[",

               MQLInfoString(MQL_PROGRAM_NAME),

               "][INDICATOR][ERROR] Unable to create ORB box",

               " | Error=",

               GetLastError());

 

         return;

        }

 

      ObjectSetInteger(0, objectName, OBJPROP_COLOR, BoxColor);

      ObjectSetInteger(0, objectName, OBJPROP_BACK, true);

      ObjectSetInteger(0, objectName, OBJPROP_FILL, false);

      ObjectSetInteger(0, objectName, OBJPROP_WIDTH, 1);

      ObjectSetInteger(0, objectName, OBJPROP_SELECTABLE, false);

      ObjectSetInteger(0, objectName, OBJPROP_HIDDEN, true);

     }

   else

     {

      ObjectMove(0,

                 objectName,

                 0,

                 startTime,

                 rangeHigh);

 

      ObjectMove(0,

                 objectName,

                 1,

                 endTime,

                 rangeLow);

     }

  }

 

 

//+------------------------------------------------------------------+

//| Validates the strategy inputs                                    |

//+------------------------------------------------------------------+

bool ValidateInputs()

  {

   if(RangeStartHour < 0 || RangeStartHour > 23)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Invalid RangeStartHour");

 

      return(false);

     }

 

   if(RangeEndHour < 0 || RangeEndHour > 23)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Invalid RangeEndHour");

 

      return(false);

     }

 

   if(RangeStartMinute < 0 || RangeStartMinute > 59)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Invalid RangeStartMinute");

 

      return(false);

     }

 

   if(RangeEndMinute < 0 || RangeEndMinute > 59)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Invalid RangeEndMinute");

 

      return(false);

     }

 

   if(RiskReward <= 0.0)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] RiskReward must be greater than zero");

 

      return(false);

     }

 

   datetime startTime =

      TodayTime(RangeStartHour, RangeStartMinute);

 

   datetime endTime =

      TodayTime(RangeEndHour, RangeEndMinute);

 

   if(endTime <= startTime)

     {

      Print("[",

            MQLInfoString(MQL_PROGRAM_NAME),

            "][INDICATOR][ERROR] Range end time must be later than range start time");

 

      return(false);

     }

 

   return(true);

  }

 

 

//+------------------------------------------------------------------+

//| OnInit                                                           |

//+------------------------------------------------------------------+

int OnInit()

  {

   IndicatorLoadTime = TimeCurrent();

   LastBreakoutBarTime = 0;

   ActivityDetectedAfterSignal = false;

 

   ShowGraphics = true;

 

   if(MQLInfoInteger(MQL_TESTER) &&

      !MQLInfoInteger(MQL_VISUAL_MODE))

     {

      ShowGraphics = false;

     }

 

   if(!ValidateInputs())

      return(INIT_PARAMETERS_INCORRECT);

 

   Print("[",

         MQLInfoString(MQL_PROGRAM_NAME),

         "][INDICATOR][OnInit] ORB indicator started",

         " | Symbol=",

         _Symbol,

         " | BreakoutTimeframe=",

         EnumToString(BreakoutTimeframe),

         " | ShowGraphics=",

         ShowGraphics ? "true" : "false",

         " | LoadTime=",

         TimeToString(IndicatorLoadTime,

                      TIME_DATE | TIME_SECONDS));

 

   return(INIT_SUCCEEDED);

  }

 

 

//+------------------------------------------------------------------+

//| OnDeinit                                                         |

//|                                                                  |

//| The duplicate-protection Global Variable is not deleted during   |

//| timeframe changes, input changes or other reinitializations.      |

//|                                                                  |

//| It is deleted only when the indicator is manually removed.       |

//+------------------------------------------------------------------+

void OnDeinit(const int reason)

  {

   if(reason == REASON_REMOVE)

     {

      GlobalVariableDel(LastSignalGVName());

 

      if(ShowGraphics)

         DeleteBox();

     }

 

   Print("[",

         MQLInfoString(MQL_PROGRAM_NAME),

         "][INDICATOR][OnDeinit] ORB indicator stopped",

         " | Symbol=",

         _Symbol,

         " | Reason=",

         reason);

  }

 

 

//+------------------------------------------------------------------+

//| OnCalculate                                                      |

//|                                                                  |

//| Main workflow:                                                   |

//|                                                                  |

//| 1. Wait until the ORB range is completed.                        |

//| 2. Calculate the ORB high and low.                               |

//| 3. Draw the box only when graphics are enabled.                  |

//| 4. Detect a breakout using a closed candle.                      |

//| 5. Calculate Stop Loss and Take Profit.                          |

//| 6. Send the signal to RiskGuard.                                 |

//| 7. Save the daily duplicate-protection status.                   |

//+------------------------------------------------------------------+

int OnCalculate(const int rates_total,

                const int prev_calculated,

                const datetime &time[],

                const double &open[],

                const double &high[],

                const double &low[],

                const double &close[],

                const long &tick_volume[],

                const long &volume[],

                const int &spread[])

  {

   if(ShowGraphics)

      DeleteOldBoxes();

 

   datetime now = TimeCurrent();

 

   datetime endTime =

      TodayTime(RangeEndHour, RangeEndMinute);

 

   //--- Wait until the ORB range is completed.

   if(now < endTime)

      return(rates_total);

 

   double rangeHigh = 0.0;

   double rangeLow  = 0.0;

 

   if(!GetOrbRange(rangeHigh, rangeLow))

      return(rates_total);

 

   bool signalAlreadySent = AlreadySentToday();

 

   //--- Draw the box only in live use or visual backtests.

   if(ShowGraphics && !signalAlreadySent)

      DrawBox(rangeHigh, rangeLow);

 

   //--- Manage the box after a signal has already been sent.

   if(signalAlreadySent)

     {

      bool hasStrategyActivity =

         HasRiskGuardStrategyPositionOrOrder();

 

      if(hasStrategyActivity)

         ActivityDetectedAfterSignal = true;

 

      if(ShowGraphics &&

         ActivityDetectedAfterSignal &&

         !hasStrategyActivity)

        {

         DeleteBox();

        }

 

      return(rates_total);

     }

 

   //--- Prevent retroactive signals.

   //--- If the indicator is loaded today after the range has ended,

   //--- no breakout that occurred before loading may be recovered.

   if(DayKey(IndicatorLoadTime) == DayKey(now) &&

      IndicatorLoadTime > endTime)

     {

      return(rates_total);

     }

 

   MqlRates breakoutRates[];

   ArraySetAsSeries(breakoutRates, true);

 

   int copiedBars =

      CopyRates(_Symbol,

                BreakoutTimeframe,

                0,

                3,

                breakoutRates);

 

   if(copiedBars < 3)

      return(rates_total);

 

   //--- Use only the last closed candle.

   datetime closedBarTime = breakoutRates[1].time;

 

   //--- Process each closed candle only once.

   if(closedBarTime == LastBreakoutBarTime)

      return(rates_total);

 

   LastBreakoutBarTime = closedBarTime;

 

   //--- Ignore candles closed before completion of the ORB range.

   if(closedBarTime < endTime)

      return(rates_total);

 

   double barClose = breakoutRates[1].close;

   double boxSize  = rangeHigh - rangeLow;

 

   if(boxSize <= 0.0)

      return(rates_total);

 

   double normalizedEntryPercent = EntryPercent;

 

   if(normalizedEntryPercent < 0.0)

      normalizedEntryPercent = 0.0;

 

   if(normalizedEntryPercent > 99.0)

      normalizedEntryPercent = 99.0;

 

   double ask =

      SymbolInfoDouble(_Symbol, SYMBOL_ASK);

 

   double bid =

      SymbolInfoDouble(_Symbol, SYMBOL_BID);

 

   if(ask <= 0.0 || bid <= 0.0)

      return(rates_total);

 

 

   //+---------------------------------------------------------------+

   //| BUY breakout                                                  |

   //+---------------------------------------------------------------+

   if(barClose > rangeHigh)

     {

      double stopPrice    = 0.0;

      double takePrice    = 0.0;

      double pendingPrice = 0.0;

 

      //--- Market BUY signal.

      if(normalizedEntryPercent <= 0.0)

        {

         stopPrice = rangeLow;

 

         double riskDistance = ask - stopPrice;

 

         if(riskDistance <= 0.0)

            return(rates_total);

 

         takePrice =

            ask + riskDistance * RiskReward;

 

         SendRiskGuardConfig2Signal(stopPrice,

                                    takePrice);

        }

 

      //--- Pending BUY signal inside the ORB box.

      else

        {

         pendingPrice =

            rangeHigh -

            boxSize *

            normalizedEntryPercent /

            100.0;

 

         stopPrice = rangeLow;

 

         double riskDistance =

            pendingPrice - stopPrice;

 

         if(riskDistance <= 0.0)

            return(rates_total);

 

         takePrice =

            pendingPrice +

            riskDistance *

            RiskReward;

 

         SendRiskGuardConfig2Signal(stopPrice,

                                    takePrice,

                                    pendingPrice);

        }

 

      //--- Save only after the RiskGuard signal variables exist.

      SaveSignalToday();

 

      return(rates_total);

     }

 

 

   //+---------------------------------------------------------------+

   //| SELL breakout                                                 |

   //+---------------------------------------------------------------+

   if(barClose < rangeLow)

     {

      double stopPrice    = 0.0;

      double takePrice    = 0.0;

      double pendingPrice = 0.0;

 

      //--- Market SELL signal.

      if(normalizedEntryPercent <= 0.0)

        {

         stopPrice = rangeHigh;

 

         double riskDistance =

            stopPrice - bid;

 

         if(riskDistance <= 0.0)

            return(rates_total);

 

         takePrice =

            bid -

            riskDistance *

            RiskReward;

 

         SendRiskGuardConfig2Signal(stopPrice,

                                    takePrice);

        }

 

      //--- Pending SELL signal inside the ORB box.

      else

        {

         pendingPrice =

            rangeLow +

            boxSize *

            normalizedEntryPercent /

            100.0;

 

         stopPrice = rangeHigh;

 

         double riskDistance =

            stopPrice - pendingPrice;

 

         if(riskDistance <= 0.0)

            return(rates_total);

 

         takePrice =

            pendingPrice -

            riskDistance *

            RiskReward;

 

         SendRiskGuardConfig2Signal(stopPrice,

                                    takePrice,

                                    pendingPrice);

        }

 

      //--- Save only after the RiskGuard signal variables exist.

      SaveSignalToday();

 

      return(rates_total);

     }

 

   return(rates_total);

  }

//+------------------------------------------------------------------+