Crafting a Dark Cloud Cover Reversal Hunter with MQL5

Introduction

Greetings, forex storm chasers! Picture the forex market as a wild jungle, with prices soaring like clear skies before a storm rolls in. The Dark Cloud Cover EA is your high-tech weather radar, an MQL5 bot that detects the bearish Dark Cloud Cover candlestick pattern, marks it with a red arrow, and executes sell trades with precision. This EA scans for a bullish candle followed by a bearish one that signals a reversal, ready to capitalize on market shifts. This article is your expedition log, guiding you through the code with crystal-clear detail for beginners, a flow smoother than a jungle stream, and examples—like trading EURUSD reversals—to keep you engaged. We’ll quote variables (e.g., "openPositions") and functions (e.g., "OnInit()") for clarity, balancing pro insights with a sprinkle of charm. Ready to chase those bearish clouds? Let’s embark on this reversal hunt!

Strategy Blueprint

The Dark Cloud Cover EA automates bearish reversal trading:

• Pattern Detection: Identifies a two-candle pattern where a bullish candle (open below close) is followed by a bearish candle (open above close) that opens above the bullish candle’s high and closes below its midpoint but above its low.

• Visualization: Draws a red arrow on the chart to mark the pattern.

• Trading: Executes a sell trade with a 0.5-lot size, 300-pip stop loss, and 300-pip take profit, limited to one open position.

• Settings: Fixed parameters for simplicity, with room to add customization. It’s like a radar that spots storm clouds, marks them, and trades the downpour, ideal for traders targeting reversals after uptrends. See below.

Code Implementation

Let’s trek through the MQL5 code like storm chasers tracking a brewing tempest, building our reversal hunter step by step. We’ll flow from setting up the radar to spotting the pattern, visualizing it, trading, and cleaning up, with transitions as seamless as a jungle breeze. Each section includes code blocks, detailed explanations of what we’re doing, and examples to keep you engaged, all while staying beginner-friendly and professional.

Step 1: Setting Up the Storm Radar—Preparing the Hunt

We start by rigging our weather station, defining the EA’s structure to chase Dark Cloud Cover patterns.

//+------------------------------------------------------------------+
//|                        Copyright 2025, Forex Algo-Trader, Allan. |
//|                           https://youtube.com/@ForexAlgo-Trader? |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, ALLAN MUNENE MUTIIRIA. #@Forex Algo-Trader"
#property link      "https://youtube.com/@ForexAlgo-Trader?"
#property description "======= IMPORTANT =======\n"
#property description "1. This is a FREE EA."
#property description "2. To get the source code of the EA, follow the Copyright link."
#property description "3. In case of anything, contact developer via the link provided."
#property description "Hope you will enjoy the EA Logic.\n"
#property description "*** HAPPY TRADING! ***"
#property version   "1.00"

#include <Trade\Trade.mqh>
CTrade openPositions;

int OnInit()
{
   return(INIT_SUCCEEDED);
}

We set up our radar with a #property header, declaring the EA as a free offering by Allan in 2025 with a YouTube link, like calibrating our storm tracker. We include "Trade/Trade.mqh" for trading via "openPositions", a CTrade object, like our radar’s control unit. In "OnInit()", we return INIT_SUCCEEDED, signaling, “Radar’s online, ready to hunt!” This minimal setup primes us for chasing bearish clouds, keeping things lean for the pattern hunt.

Step 2: Spotting the Storm—Detecting the Dark Cloud Cover Pattern

With the radar set, we scan the market for the Dark Cloud Cover pattern, like spotting storm clouds on the horizon.

int getDarkCloudCover(){
   datetime time = iTime(_Symbol,PERIOD_CURRENT,1);
   double open1 = iOpen(_Symbol,PERIOD_CURRENT,1);
   double high1 = iHigh(_Symbol,PERIOD_CURRENT,1);
   double low1 = iLow(_Symbol,PERIOD_CURRENT,1);
   double close1 = iClose(_Symbol,PERIOD_CURRENT,1);
   double open2 = iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2 = iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2 = iLow(_Symbol,PERIOD_CURRENT,2);
   double close2 = iClose(_Symbol,PERIOD_CURRENT,2);
   double candlesize_2 = high2 - low2;
   double candleMidpoint_2 = high2 - (candlesize_2/2);
   
   if (open1 > close1){
      if (open2 < close2){
         if (open1 > high2){
            if (close1 < candleMidpoint_2 && close1 > low2){
               Print("___WE FOUND DARK CLOUD COVER, SELL!!!");
               createObject(time,high1,234,clrRed);
               return -1;
            }
         }
      }
   }
   return 0;
}

In "getDarkCloudCover()", we grab data for the latest two candles using "iTime()", "iOpen()", "iHigh()", "iLow()", "iClose()". We calculate the second candle’s size ("candlesize_2") and midpoint ("candleMidpoint_2"). The pattern requires: a bullish second candle ("open2 < close2"), a bearish first candle ("open1 > close1"), the first candle opening above the second’s high ("open1 > high2"), and closing below its midpoint but above its low ("close1 < candleMidpoint_2 && close1 > low2"). If valid, we log with "Print()" (“WE FOUND DARK CLOUD COVER, SELL!!!”), call "createObject()" to mark it, and return -1, like spotting a storm on EURUSD at 1.2000. Otherwise, we return 0, like clear skies.

Step 3: Marking the Storm—Visualizing the Pattern

Pattern spotted? We mark it with a red arrow, like planting a warning flag for the storm.

void createObject(datetime time,double price, int arrawCode, color clr){
   string objName = "Dark Cloud Cover";
   if (ObjectCreate(0,objName,OBJ_ARROW,0,time,price)){
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      ObjectSetInteger(0,objName,OBJPROP_WIDTH,4);
      ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
   }
}

In "createObject()", we create a red arrow at the bearish candle’s high using "ObjectCreate(OBJ_ARROW)", "ObjectSetInteger()", with a 4-pixel width and bottom anchor, like a neon flag on EURUSD’s chart at 1.2000 signaling “Storm’s here!” This makes the pattern pop visually, guiding traders to the reversal.

Step 4: Chasing the Downpour—Trading the Pattern

With the storm marked, we trade the sell signal, like chasing the rain’s fall.

void OnTick()
{
   getDarkCloudCover();
   if (PositionsTotal()+1 > 1) return;
   if (getDarkCloudCover() == -1){
      double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);
      double sl = 300;
      double tp = 300;
      openPositions.Sell(0.5,_Symbol,bid,bid+sl*_Point,bid-tp*_Point);
   }
}

In "OnTick()", we call "getDarkCloudCover()". If it returns -1 and no positions are open ("PositionsTotal()"), we grab the bid price with "SymbolInfoDouble()", set a 300-pip stop loss ("sl") and take profit ("tp"), and execute a sell with "openPositions.Sell()" using 0.5 lots, like selling EURUSD at 1.2000 with a stop at 1.2300 and target at 1.1700. The position limit ensures one trade at a time, like chasing one storm without overloading.

Step 5: Packing Up the Radar—Cleaning Up Tracks

When the chase is over, we tidy up to leave the jungle clean.

void OnDeinit(const int reason)
{
}

In "OnDeinit()", we leave it empty, as no cleanup is coded, like leaving our radar’s markers in place. We could add "ObjectsDeleteAll()" to clear "Dark Cloud Cover" arrows, like packing up gear, but for now, it’s a light cleanup, ready for the next storm.

Why This EA’s a Storm-Chasing Legend (and Keeps You Engaged!)

This EA is a reversal-hunting legend, spotting Dark Cloud Cover patterns like a radar tracking storm clouds, marking them with red arrows, and trading sells with precision. It’s pro-grade with a simple setup, ready for customization like adding lot size inputs. Example? Catch a Dark Cloud Cover on GBPUSD at 1.3500 after a rally, sell with a 300-pip stop and target, nabbing 200 pips as bears take over—pure storm-chasing gold! Beginners can follow, and pros can refine it, making it a must-have for reversal traders.

Putting It All Together

To launch this EA:

1. Open MetaEditor in MetaTrader 5 like setting up a weather station.

2. Paste the code, compile (F5), and check for typos—no chaser wants a faulty radar.

3. Drop the EA on your chart, enable AutoTrading, and watch for red arrows and sell trades.

4. Test on a demo first—real pips deserve a practice chase!

Conclusion

We’ve crafted a Dark Cloud Cover reversal hunter that spots bearish patterns, marks them vividly, and trades with precision. This MQL5 code is our storm radar, explained with detail to make you a trading chaser, a touch of charm to keep you engaged, and flow to carry you like a jungle breeze. Ready to chase? Check our video guide on the website for a front-row seat to this reversal adventure. Now go hunt those market clouds! 🌩️

Disclaimer: Trading’s like chasing a jungle storm—thrilling but risky. Losses can exceed deposits. Test on a demo account before going live.