Gold with No Drama

Executed my Short.
Disclaimer: This is not financial advice. Trade responsibly.

from Iran with love, I made an Indicator with Grok, it shows me sell or buy signal ....
To you, with all my love...



//+------------------------------------------------------------------+
//| MFI_Divergence_Final.mq5 |
//| Copyright 2025, Built with help from Grok |
//+------------------------------------------------------------------+
#property copyright "Built with help from Grok"
#property version "2.00"
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 2
//--- Bullish Arrow
#property indicator_label1 "Bullish Divergence"
#property indicator_type1 DRAW_ARROW
#property indicator_color1 clrLime
#property indicator_style1 STYLE_SOLID
#property indicator_width1 3
//--- Bearish Arrow
#property indicator_label2 "Bearish Divergence"
#property indicator_type2 DRAW_ARROW
#property indicator_color2 clrRed
#property indicator_style2 STYLE_SOLID
#property indicator_width2 3
//--- Inputs
input int MFI_Period = 14; // دوره MFI
input int Strength = 5; // قدرت swing (چپ و راست – برای حساسیت کمتر بزرگتر کن)
input double Deviation = 20; // فاصله فلش از قیمت (به نقطه)
//--- Buffers
double BullishBuffer[];
double BearishBuffer[];
//--- Handle
int MFI_Handle = INVALID_HANDLE;
//+------------------------------------------------------------------+
//| Initialization |
//+------------------------------------------------------------------+
int OnInit()
{
SetIndexBuffer(0, BullishBuffer, INDICATOR_DATA);
SetIndexBuffer(1, BearishBuffer, INDICATOR_DATA);
PlotIndexSetInteger(0, PLOT_ARROW, 233); // فلش خرید
PlotIndexSetInteger(1, PLOT_ARROW, 234); // فلش فروش
MFI_Handle = iMFI(_Symbol, _Period, MFI_Period, VOLUME_TICK);
if(MFI_Handle == INVALID_HANDLE)
{
Print("خطا در ایجاد MFI");
return(INIT_FAILED);
}
IndicatorSetString(INDICATOR_SHORTNAME, "MFI Divergence Final");
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Deinitialization |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
if(MFI_Handle != INVALID_HANDLE)
IndicatorRelease(MFI_Handle);
}
//+------------------------------------------------------------------+
//| Main calculation |
//+------------------------------------------------------------------+
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(rates_total < Strength * 2 + 50) return(0);
double MFI[];
ArraySetAsSeries(MFI, true);
if(CopyBuffer(MFI_Handle, 0, 0, rates_total, MFI) <= 0) return(0);
ArraySetAsSeries(BullishBuffer, true);
ArraySetAsSeries(BearishBuffer, true);
ArraySetAsSeries(low, true);
ArraySetAsSeries(high, true);
int start = (prev_calculated == 0) ? rates_total - Strength - 1 : prev_calculated - 1;
for(int i = start; i >= Strength; i--)
{
BullishBuffer[i] = EMPTY_VALUE;
BearishBuffer[i] = EMPTY_VALUE;
// Bullish Divergence
if(IsSwingLow(i, low, Strength))
{
int prev = FindPrevSwingLow(i + Strength + 1, low, Strength);
if(prev != -1 && low[i] < low[prev] && MFI[i] > MFI[prev])
BullishBuffer[i] = low[i] - Deviation * _Point;
}
// Bearish Divergence
if(IsSwingHigh(i, high, Strength))
{
int prev = FindPrevSwingHigh(i + Strength + 1, high, Strength);
if(prev != -1 && high[i] > high[prev] && MFI[i] < MFI[prev])
BearishBuffer[i] = high[i] + Deviation * _Point;
}
}
return(rates_total);
}
//+------------------------------------------------------------------+
//| چک کردن swing low |
//+------------------------------------------------------------------+
bool IsSwingLow(int bar, const double &low[], int str)
{
double val = low[bar];
for(int k = 1; k <= str; k++)
{
if(bar + k >= ArraySize(low) || low[bar + k] < val) return false;
if(bar - k < 0 || low[bar - k] < val) return false;
}
return true;
}
//+------------------------------------------------------------------+
//| چک کردن swing high |
//+------------------------------------------------------------------+
bool IsSwingHigh(int bar, const double &high[], int str)
{
double val = high[bar];
for(int k = 1; k <= str; k++)
{
if(bar + k >= ArraySize(high) || high[bar + k] > val) return false;
if(bar - k < 0 || high[bar - k] > val) return false;
}
return true;
}
//+------------------------------------------------------------------+
//| پیدا کردن swing low قبلی |
//+------------------------------------------------------------------+
int FindPrevSwingLow(int start, const double &low[], int str)
{
for(int i = start; i < ArraySize(low) - str; i++)
if(IsSwingLow(i, low, str)) return i;
return -1;
}
//+------------------------------------------------------------------+
//| پیدا کردن swing high قبلی |
//+------------------------------------------------------------------+
int FindPrevSwingHigh(int start, const double &high[], int str)
{
for(int i = start; i < ArraySize(high) - str; i++)
if(IsSwingHigh(i, high, str)) return i;
return -1;
}
//+------------------------------------------------------------------+

you can change it to EA yourself for auto trade....

Market is bearish but the bulls are fighting with everything they've got left let's see who wins the battle

Did you test it?

The only untested low is 4170.06,my expectation is Gold ffirst goes down takes the low, then rallies.
No doubt the comments will be oh the cut was priced in, then traders suddenly thought something else and changed their minds.

If we rally first and take the Asian session high then, I will wait for a spike and go short.

Just correcting the errors in the code and converting to MT4


//+------------------------------------------------------------------+
//| MFI_Divergence_Final.mq4 |
//| MT4 version - MFI divergence with swing detection |
//+------------------------------------------------------------------+
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Lime
#property indicator_width1 3
#property indicator_color2 Red
#property indicator_width2 3
//---- inputs
input int MFI_Period = 14; // MFI period
input int Strength = 5; // swing strength (bars left/right)
input double Deviation = 20; // arrow distance from price (points)
//---- indicator buffers
double BullishBuffer[];
double BearishBuffer[];
//---- internal MFI array
double MFIArray[];
//+------------------------------------------------------------------+
//| Initialization |
//+------------------------------------------------------------------+
int OnInit()
{
IndicatorShortName("MFI Divergence Final");
//--- Bullish buffer (up arrows)
SetIndexStyle(0, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexBuffer(0, BullishBuffer);
SetIndexArrow(0, 233); // Wingdings arrow code
SetIndexLabel(0, "Bullish Divergence");
SetIndexEmptyValue(0, EMPTY_VALUE);
ArraySetAsSeries(BullishBuffer, true);
//--- Bearish buffer (down arrows)
SetIndexStyle(1, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexBuffer(1, BearishBuffer);
SetIndexArrow(1, 234); // Wingdings arrow code
SetIndexLabel(1, "Bearish Divergence");
SetIndexEmptyValue(1, EMPTY_VALUE);
ArraySetAsSeries(BearishBuffer, true);
//--- MFI array as series
ArraySetAsSeries(MFIArray, true);
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Deinitialization (nothing special needed in MT4) |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
// no handles to release in MT4
}
//+------------------------------------------------------------------+
//| Main calculation |
//+------------------------------------------------------------------+
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[])
{
//--- we need enough bars for swings + MFI
if(rates_total < Strength * 2 + 50)
return(0);
//--- resize and fill MFI values
int total = rates_total;
ArrayResize(MFIArray, total);
ArraySetAsSeries(MFIArray, true);
// fill MFI for all bars (simple, safe version)
for(int i = 0; i < total; i++)
MFIArray[i] = iMFI(NULL, 0, MFI_Period, i);
//--- choose starting bar to recalc
int start;
if(prev_calculated == 0)
start = rates_total - Strength - 1;
else
start = prev_calculated - 1;
if(start < Strength)
start = Strength;
//--- clear old values and search for divergences
for(int bar = start; bar >= Strength; bar--)
{
BullishBuffer[bar] = EMPTY_VALUE;
BearishBuffer[bar] = EMPTY_VALUE;
//--- Bullish divergence: price lower low, MFI higher low
if(IsSwingLow(bar, low, Strength))
{
int prevLow = FindPrevSwingLow(bar + Strength + 1, low, Strength);
if(prevLow != -1)
{
if(low[bar] < low[prevLow] && MFIArray[bar] > MFIArray[prevLow])
BullishBuffer[bar] = low[bar] - Deviation * Point;
}
}
//--- Bearish divergence: price higher high, MFI lower high
if(IsSwingHigh(bar, high, Strength))
{
int prevHigh = FindPrevSwingHigh(bar + Strength + 1, high, Strength);
if(prevHigh != -1)
{
if(high[bar] > high[prevHigh] && MFIArray[bar] < MFIArray[prevHigh])
BearishBuffer[bar] = high[bar] + Deviation * Point;
}
}
}
return(rates_total);
}
//+------------------------------------------------------------------+
//| Check swing low |
//+------------------------------------------------------------------+
bool IsSwingLow(int bar, const double &low[], int str)
{
double val = low[bar];
for(int k = 1; k <= str; k++)
{
// right side
if(bar + k >= ArraySize(low))
return(false);
if(low[bar + k] < val)
return(false);
// left side
if(bar - k < 0)
return(false);
if(low[bar - k] < val)
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Check swing high |
//+------------------------------------------------------------------+
bool IsSwingHigh(int bar, const double &high[], int str)
{
double val = high[bar];
for(int k = 1; k <= str; k++)
{
// right side
if(bar + k >= ArraySize(high))
return(false);
if(high[bar + k] > val)
return(false);
// left side
if(bar - k < 0)
return(false);
if(high[bar - k] > val)
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Find previous swing low (older bar index) |
//+------------------------------------------------------------------+
int FindPrevSwingLow(int start, const double &low[], int str)
{
int size = ArraySize(low);
for(int i = start; i < size - str; i++)
{
if(IsSwingLow(i, low, str))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
//| Find previous swing high (older bar index) |
//+------------------------------------------------------------------+
int FindPrevSwingHigh(int start, const double &high[], int str)
{
int size = ArraySize(high);
for(int i = start; i < size - str; i++)
{
if(IsSwingHigh(i, high, str))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+

Lets see if we caninprove this indicator ;-)

how can i use this on MT?

4200 is where it’s at and more than likely will be

Improved Code

//+------------------------------------------------------------------+
//| MFI_Divergence_Final.mq4 |
//| MT4 - MFI swing divergence (improved) |
//+------------------------------------------------------------------+
#property strict
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Lime
#property indicator_width1 3
#property indicator_color2 Red
#property indicator_width2 3
//---- inputs
input int MFI_Period = 14; // MFI period
input int Strength = 5; // swing strength (bars left/right)
input double Deviation = 20; // arrow distance from price (points)
//---- indicator buffers
double BullishBuffer[];
double BearishBuffer[];
//+------------------------------------------------------------------+
//| Initialization |
//+------------------------------------------------------------------+
int OnInit()
{
IndicatorShortName("MFI Divergence Final");
//--- Bullish buffer (up arrows)
SetIndexStyle(0, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexBuffer(0, BullishBuffer);
SetIndexArrow(0, 233); // Wingdings arrow UP
SetIndexLabel(0, "Bullish Divergence");
SetIndexEmptyValue(0, EMPTY_VALUE);
ArraySetAsSeries(BullishBuffer, true);
//--- Bearish buffer (down arrows)
SetIndexStyle(1, DRAW_ARROW, STYLE_SOLID, 3);
SetIndexBuffer(1, BearishBuffer);
SetIndexArrow(1, 234); // Wingdings arrow DOWN
SetIndexLabel(1, "Bearish Divergence");
SetIndexEmptyValue(1, EMPTY_VALUE);
ArraySetAsSeries(BearishBuffer, true);
// draw begins only after we have enough bars for swings
int begin = Strength * 2 + MFI_Period;
SetIndexDrawBegin(0, begin);
SetIndexDrawBegin(1, begin);
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Deinitialization |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
// nothing to release in MT4
}
//+------------------------------------------------------------------+
//| Main calculation |
//+------------------------------------------------------------------+
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[])
{
//--- safety check
if(rates_total <= Strength * 2 + MFI_Period)
return(0);
//--- where to start recalculating
int start;
if(prev_calculated == 0)
{
// first run: calculate almost all bars (skip earliest Strength bars)
start = rates_total - Strength - 1;
}
else
{
// recalc only the newest part + a cushion for swing detection
start = rates_total - prev_calculated + Strength;
if(start > rates_total - Strength - 1)
start = rates_total - Strength - 1;
}
//--- main loop (series arrays: bar 0 = newest)
for(int bar = start; bar >= Strength; bar--)
{
BullishBuffer[bar] = EMPTY_VALUE;
BearishBuffer[bar] = EMPTY_VALUE;
//--- Bullish divergence: price lower low, MFI higher low
if(IsSwingLow(bar, low, Strength))
{
int prevLow = FindPrevSwingLow(bar + Strength + 1, low, Strength);
if(prevLow != -1)
{
double mfiCur = iMFI(NULL, 0, MFI_Period, bar);
double mfiPrev = iMFI(NULL, 0, MFI_Period, prevLow);
if(low[bar] < low[prevLow] && mfiCur > mfiPrev)
BullishBuffer[bar] = low[bar] - Deviation * Point;
}
}
//--- Bearish divergence: price higher high, MFI lower high
if(IsSwingHigh(bar, high, Strength))
{
int prevHigh = FindPrevSwingHigh(bar + Strength + 1, high, Strength);
if(prevHigh != -1)
{
double mfiCur = iMFI(NULL, 0, MFI_Period, bar);
double mfiPrev = iMFI(NULL, 0, MFI_Period, prevHigh);
if(high[bar] > high[prevHigh] && mfiCur < mfiPrev)
BearishBuffer[bar] = high[bar] + Deviation * Point;
}
}
}
return(rates_total);
}
//+------------------------------------------------------------------+
//| Check swing low |
//+------------------------------------------------------------------+
bool IsSwingLow(int bar, const double &low[], int str)
{
double val = low[bar];
int size = ArraySize(low);
for(int k = 1; k <= str; k++)
{
// right side (older bars: higher index)
if(bar + k >= size || low[bar + k] < val)
return(false);
// left side (newer bars: lower index)
if(bar - k < 0 || low[bar - k] < val)
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Check swing high |
//+------------------------------------------------------------------+
bool IsSwingHigh(int bar, const double &high[], int str)
{
double val = high[bar];
int size = ArraySize(high);
for(int k = 1; k <= str; k++)
{
// right side (older bars)
if(bar + k >= size || high[bar + k] > val)
return(false);
// left side (newer bars)
if(bar - k < 0 || high[bar - k] > val)
return(false);
}
return(true);
}
//+------------------------------------------------------------------+
//| Find previous swing low (older bar index) |
//+------------------------------------------------------------------+
int FindPrevSwingLow(int start, const double &low[], int str)
{
int size = ArraySize(low);
for(int i = start; i < size - str; i++)
{
if(IsSwingLow(i, low, str))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+
//| Find previous swing high (older bar index) |
//+------------------------------------------------------------------+
int FindPrevSwingHigh(int start, const double &high[], int str)
{
int size = ArraySize(high);
for(int i = start; i < size - str; i++)
{
if(IsSwingHigh(i, high, str))
return(i);
}
return(-1);
}
//+------------------------------------------------------------------+

[quote=tjwohn;15501355]{quote} how can i use this on MT?[/quote

OK when you are on the terminal press F4
then open a old indicator file, copy the code, paste it into the old indicator, rename it and compile, you will see the indicator appear.

If you want to use EA. You can use it https://www.mql5.com/en/market/product/142876?source=Site+Profile+Seller#description

Update: Will close the entry manually 100% ten minutes before news if SL or TP not hit. I don’t want this trade turning 50/50 because of the news.

it is really quite who knows why ..

Gold isn't waiting for the news it has been moving all day , sell the high always and you will be on profit

FOMC after 30 mins

the parameter "Strength" causes to shifting. For example, if it is 5, then signal arrow appears 5 candle back

If there is no reaction to the news it’s officially Christmas season for me lol