713 lines
18 KiB
Markdown
713 lines
18 KiB
Markdown
### USER
|
|
Strategy 6: KI FVG Mitigation
|
|
|
|
### ASSISTANT
|
|
# 🎯 Complete Strategy 6: KI FVG Mitigation Implementation
|
|
|
|
Based on your **SaherElm Framework** and **X121XKI Indicator** buffers, here is the complete implementation for **Strategy 6: KI FVG Mitigation**.
|
|
|
|
This strategy focuses on **Fair Value Gap mitigation** where price returns to fill the FVG with **X121XKI confirmation** for high-probability continuation entries.
|
|
|
|
```mql5
|
|
/**
|
|
* Check Bar Has Signal Based on Strategy 6 ...
|
|
* KI FVG Mitigation
|
|
*
|
|
* @param bar: XOHCL, reference to Bar ...
|
|
* @param zone: XBoxZone, reference to holds affected zone ...
|
|
* @param targets: XTarget, reference to detected Signal's Targets collections ...
|
|
* @param dir: ENUM_X_DIRECTION, detected Signal's direction ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool Strategy6HasSignal(
|
|
XOHCL &bar,
|
|
XBoxZone &zone,
|
|
XTarget &targets[],
|
|
ENUM_X_DIRECTION &dir //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
//
|
|
// Prepare ...
|
|
zone.Clean();
|
|
XClean(targets);
|
|
dir = X_DIRECTION_NONE;
|
|
//
|
|
// Validate ...
|
|
result = bar.IsValid() && kiParser.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
//
|
|
// Configuration ...
|
|
int barIndex = bar.Index() + 1;
|
|
double points = GetPoints(symbol);
|
|
int minFVGPoints = 20; // Minimum FVG size in points
|
|
int kiConfirmationBars = 3; // Bars for KI confirmation
|
|
double minScore = 16.0; // Minimum score for signal
|
|
//
|
|
// State Variables ...
|
|
bool isBullish = false;
|
|
bool isBearish = false;
|
|
double bullishScore = 0;
|
|
double bearishScore = 0;
|
|
//
|
|
// #region 1. Detect Fair Value Gaps ...
|
|
//
|
|
// Detect Fair Value Gaps ...
|
|
XBoxZone bullishFVGs[];
|
|
XBoxZone bearishFVGs[];
|
|
//
|
|
int bullishFVGCount = poiDetector.CollectFVGs(bar, bullishFVGs, 5, 10, 100);
|
|
int bearishFVGCount = poiDetector.CollectFVGs(bar, bearishFVGs, 5, 10, 100);
|
|
//
|
|
// Validate FVG Size ...
|
|
XBoxZone validBullishFVGs[];
|
|
XBoxZone validBearishFVGs[];
|
|
//
|
|
// Filter Bullish FVGs ...
|
|
for (int i = 0; i < bullishFVGCount; i++)
|
|
{
|
|
double fvgRange = (bullishFVGs[i].upper - bullishFVGs[i].lower) / points;
|
|
bool isValidSize = fvgRange >= minFVGPoints;
|
|
bool isNotBreaked = !IsXValid(bullishFVGs[i].breakAt);
|
|
bool isNotFilled = !IsFVGFilled(bar, bullishFVGs[i]);
|
|
//
|
|
if (isValidSize && isNotBreaked && isNotFilled)
|
|
{
|
|
AddRef(bullishFVGs[i], validBullishFVGs);
|
|
}
|
|
}
|
|
//
|
|
// Filter Bearish FVGs ...
|
|
for (int i = 0; i < bearishFVGCount; i++)
|
|
{
|
|
double fvgRange = (bearishFVGs[i].upper - bearishFVGs[i].lower) / points;
|
|
bool isValidSize = fvgRange >= minFVGPoints;
|
|
bool isNotBreaked = !IsXValid(bearishFVGs[i].breakAt);
|
|
bool isNotFilled = !IsFVGFilled(bar, bearishFVGs[i]);
|
|
//
|
|
if (isValidSize && isNotBreaked && isNotFilled)
|
|
{
|
|
AddRef(bearishFVGs[i], validBearishFVGs);
|
|
}
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 2. Check FVG Mitigation (Price Returning to FVG) ...
|
|
//
|
|
// Check Price is Mitigating Bullish FVG ...
|
|
XBoxZone mitigatingBullishFVGs[];
|
|
for (int i = 0; i < ArraySize(validBullishFVGs); i++)
|
|
{
|
|
XBoxZone iFVG = validBullishFVGs[i];
|
|
//
|
|
// Check Price is Inside or Near FVG ...
|
|
bool isMitigating = IsPriceInFVG(bar, iFVG, 10 * points);
|
|
bool isRecent = (bar.time - iFVG.from) <= (PeriodSeconds(period) * 50); // Within 50 bars
|
|
//
|
|
if (isMitigating && isRecent)
|
|
{
|
|
AddRef(iFVG, mitigatingBullishFVGs);
|
|
}
|
|
}
|
|
//
|
|
// Check Price is Mitigating Bearish FVG ...
|
|
XBoxZone mitigatingBearishFVGs[];
|
|
for (int i = 0; i < ArraySize(validBearishFVGs); i++)
|
|
{
|
|
XBoxZone iFVG = validBearishFVGs[i];
|
|
//
|
|
// Check Price is Inside or Near FVG ...
|
|
bool isMitigating = IsPriceInFVG(bar, iFVG, 10 * points);
|
|
bool isRecent = (bar.time - iFVG.from) <= (PeriodSeconds(period) * 50); // Within 50 bars
|
|
//
|
|
if (isMitigating && isRecent)
|
|
{
|
|
AddRef(iFVG, mitigatingBearishFVGs);
|
|
}
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 3. KI Trend Confirmation ...
|
|
//
|
|
// Check KI Fast State ...
|
|
bool kiFastBullish = kiParser.IsKIFastBullish(barIndex);
|
|
bool kiFastBearish = kiParser.IsKIFastBearish(barIndex);
|
|
//
|
|
// Check KI Fast Switch (Trend Change) ...
|
|
bool kiFastSwitchedBullish = kiParser.IsKIFastSwitchedToBullish(barIndex);
|
|
bool kiFastSwitchedBearish = kiParser.IsKIFastSwitchedToBearish(barIndex);
|
|
//
|
|
// Check KI Slow Alignment (HTF Bias) ...
|
|
bool kiSlowBullish = kiParser.IsKISlowBullish(barIndex);
|
|
bool kiSlowBearish = kiParser.IsKISlowBearish(barIndex);
|
|
//
|
|
// Check KI Super Slow (Major HTF Bias) ...
|
|
bool kiSuperSlowBullish = kiParser.IsKISuperSlowBullish(barIndex);
|
|
bool kiSuperSlowBearish = kiParser.IsKISuperSlowBearish(barIndex);
|
|
//
|
|
// Check Price Position Relative to KI ...
|
|
bool priceAboveKIFast = kiParser.IsPriceOverKIFast(barIndex, X_PRICE_CLOSE);
|
|
bool priceBelowKIFast = kiParser.IsPriceUnderKIFast(barIndex, X_PRICE_CLOSE);
|
|
//
|
|
// Check KI Wave Momentum ...
|
|
bool kiWaveBullish = kiParser.IsKIWaveSwitchedToBullish(barIndex);
|
|
bool kiWaveBearish = kiParser.IsKIWaveSwitchedToBearish(barIndex);
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 4. RSI Momentum Confirmation ...
|
|
//
|
|
// Check RSI State ...
|
|
bool rsiBullish = kiParser.IsRSISwitchedToBullish(barIndex, 55, 2);
|
|
bool rsiBearish = kiParser.IsRSISwitchedToBearish(barIndex, 45, 2);
|
|
//
|
|
// Check RSI Not in Extreme Zones ...
|
|
double currentRSI = kiParser.GetRSI(barIndex);
|
|
bool rsiNotOverbought = currentRSI < 70;
|
|
bool rsiNotOversold = currentRSI > 30;
|
|
//
|
|
// Check RSI Divergence ...
|
|
bool rsiBullishDivergence = false;
|
|
bool rsiBearishDivergence = false;
|
|
//
|
|
if (barIndex + 5 < bar.TotalBars())
|
|
{
|
|
double currentRSI = kiParser.GetRSI(barIndex);
|
|
double previousRSI = kiParser.GetRSI(barIndex + 5);
|
|
double currentLow = bar.low;
|
|
double previousLow = bar.FindLowest(5, MODE_LOW);
|
|
double currentHigh = bar.high;
|
|
double previousHigh = bar.FindHighest(5, MODE_HIGH);
|
|
//
|
|
// Bullish Divergence ...
|
|
rsiBullishDivergence = (currentLow < previousLow) && (currentRSI > previousRSI);
|
|
//
|
|
// Bearish Divergence ...
|
|
rsiBearishDivergence = (currentHigh > previousHigh) && (currentRSI < previousRSI);
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 5. Volatility / Displacement ...
|
|
//
|
|
// Check Volatility Expansion ...
|
|
bool volatilityHigh = kiParser.IsVolatilityHigh(barIndex);
|
|
bool volatilitySwitchedHigh = kiParser.IsVolatilitySwitchdToHigh(barIndex);
|
|
//
|
|
// Check ATR Breakout ...
|
|
bool atrBreakoutUp = kiParser.IsATRBreakoutUp(barIndex, X_PRICE_CLOSE);
|
|
bool atrBreakoutDown = kiParser.IsATRBreakoutDown(barIndex, X_PRICE_CLOSE);
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 6. Recent Swing Detection (Liquidity) ...
|
|
//
|
|
XBoxZone swingHigh;
|
|
XBoxZone swingLow;
|
|
//
|
|
poiDetector.DetectRecentSwings(
|
|
swingHigh,
|
|
swingLow,
|
|
barIndex,
|
|
50, // swingsValidationLength
|
|
500, // loopback
|
|
period,
|
|
true // forceRefineZones
|
|
);
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 7. Calculate Scores ...
|
|
//
|
|
// Bullish FVG Mitigation Score ...
|
|
//
|
|
// FVG Mitigation Presence (Max 6 points) ...
|
|
if (ArraySize(mitigatingBullishFVGs) > 0) bullishScore += 6;
|
|
//
|
|
// KI Trend Alignment (Max 6 points) ...
|
|
if (kiFastBullish) bullishScore += 1;
|
|
if (kiSlowBullish) bullishScore += 2;
|
|
if (kiSuperSlowBullish) bullishScore += 3;
|
|
if (priceAboveKIFast) bullishScore += 1;
|
|
//
|
|
// KI Wave Momentum (Max 2 points) ...
|
|
if (kiWaveBullish) bullishScore += 2;
|
|
//
|
|
// RSI Confirmation (Max 4 points) ...
|
|
if (rsiBullish) bullishScore += 2;
|
|
if (rsiBullishDivergence) bullishScore += 4;
|
|
if (rsiNotOversold) bullishScore += 1;
|
|
//
|
|
// Volatility (Max 3 points) ...
|
|
if (volatilityHigh) bullishScore += 1;
|
|
if (volatilitySwitchedHigh) bullishScore += 2;
|
|
if (atrBreakoutUp) bullishScore += 2;
|
|
//
|
|
// FVG Quality (Max 4 points) ...
|
|
if (ArraySize(validBullishFVGs) > 0)
|
|
{
|
|
double avgFVGSize = 0;
|
|
for (int i = 0; i < ArraySize(validBullishFVGs); i++)
|
|
{
|
|
avgFVGSize += (validBullishFVGs[i].upper - validBullishFVGs[i].lower) / points;
|
|
}
|
|
avgFVGSize /= ArraySize(validBullishFVGs);
|
|
//
|
|
if (avgFVGSize >= 50) bullishScore += 4;
|
|
else if (avgFVGSize >= 30) bullishScore += 3;
|
|
else if (avgFVGSize >= 20) bullishScore += 2;
|
|
}
|
|
//
|
|
// Bearish FVG Mitigation Score ...
|
|
//
|
|
// FVG Mitigation Presence (Max 6 points) ...
|
|
if (ArraySize(mitigatingBearishFVGs) > 0) bearishScore += 6;
|
|
//
|
|
// KI Trend Alignment (Max 6 points) ...
|
|
if (kiFastBearish) bearishScore += 1;
|
|
if (kiSlowBearish) bearishScore += 2;
|
|
if (kiSuperSlowBearish) bearishScore += 3;
|
|
if (priceBelowKIFast) bearishScore += 1;
|
|
//
|
|
// KI Wave Momentum (Max 2 points) ...
|
|
if (kiWaveBearish) bearishScore += 2;
|
|
//
|
|
// RSI Confirmation (Max 4 points) ...
|
|
if (rsiBearish) bearishScore += 2;
|
|
if (rsiBearishDivergence) bearishScore += 4;
|
|
if (rsiNotOverbought) bearishScore += 1;
|
|
//
|
|
// Volatility (Max 3 points) ...
|
|
if (volatilityHigh) bearishScore += 1;
|
|
if (volatilitySwitchedHigh) bearishScore += 2;
|
|
if (atrBreakoutDown) bearishScore += 2;
|
|
//
|
|
// FVG Quality (Max 4 points) ...
|
|
if (ArraySize(validBearishFVGs) > 0)
|
|
{
|
|
double avgFVGSize = 0;
|
|
for (int i = 0; i < ArraySize(validBearishFVGs); i++)
|
|
{
|
|
avgFVGSize += (validBearishFVGs[i].upper - validBearishFVGs[i].lower) / points;
|
|
}
|
|
avgFVGSize /= ArraySize(validBearishFVGs);
|
|
//
|
|
if (avgFVGSize >= 50) bearishScore += 4;
|
|
else if (avgFVGSize >= 30) bearishScore += 3;
|
|
else if (avgFVGSize >= 20) bearishScore += 2;
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 8. Determine Direction ...
|
|
//
|
|
// Ensure Only One Direction ...
|
|
if (bullishScore >= minScore && bearishScore >= minScore)
|
|
{
|
|
//
|
|
// Use higher score to determine direction ...
|
|
if (bullishScore > bearishScore)
|
|
{
|
|
bearishScore = 0;
|
|
}
|
|
else if (bearishScore > bullishScore)
|
|
{
|
|
bullishScore = 0;
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Same score, no signal ...
|
|
bullishScore = 0;
|
|
bearishScore = 0;
|
|
}
|
|
}
|
|
//
|
|
// Check Bullish FVG Mitigation Conditions ...
|
|
isBullish =
|
|
(bullishScore >= minScore) &&
|
|
(ArraySize(mitigatingBullishFVGs) > 0) &&
|
|
(kiFastBullish || kiWaveBullish);
|
|
//
|
|
// Check Bearish FVG Mitigation Conditions ...
|
|
isBearish =
|
|
(bearishScore >= minScore) &&
|
|
(ArraySize(mitigatingBearishFVGs) > 0) &&
|
|
(kiFastBearish || kiWaveBearish);
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 9. Generate Signal ...
|
|
//
|
|
// Generate Bullish FVG Mitigation Signal ...
|
|
if (isBullish)
|
|
{
|
|
dir = X_DIRECTION_BULLISH;
|
|
//
|
|
// Select Best FVG (Youngest Valid FVG in Mitigation) ...
|
|
XBoxZone selectedFVG;
|
|
int fvgIdx = GetYoungest(mitigatingBullishFVGs);
|
|
//
|
|
if (IsValidIndex(fvgIdx))
|
|
{
|
|
selectedFVG = mitigatingBullishFVGs[fvgIdx];
|
|
}
|
|
//
|
|
// Validate Selected FVG ...
|
|
if (selectedFVG.IsValid())
|
|
{
|
|
zone = selectedFVG;
|
|
zone.type = "S6_FVG_Mitigation";
|
|
//
|
|
// Calculate Targets ...
|
|
double entry = GetEntry(symbol, dir);
|
|
//
|
|
// SL: Below FVG Lower ...
|
|
double sl = zone.lower - (10 * points);
|
|
//
|
|
// TP1: 1:1 R:R ...
|
|
double risk = MathAbs(entry - sl);
|
|
XTarget tp1;
|
|
tp1.target = entry + risk;
|
|
tp1.volumeMultiplier = 0.5;
|
|
tp1.doRF = true;
|
|
tp1.doRFOnEntry = false;
|
|
AddRef(tp1, targets);
|
|
//
|
|
// TP2: Next Liquidity (Swing High) ...
|
|
XTarget tp2;
|
|
if (swingHigh.IsValid())
|
|
{
|
|
tp2.target = swingHigh.upper + (10 * points);
|
|
}
|
|
else
|
|
{
|
|
tp2.target = entry + (risk * 2);
|
|
}
|
|
tp2.volumeMultiplier = 0.5;
|
|
tp2.doRF = false;
|
|
tp2.doRFOnEntry = false;
|
|
AddRef(tp2, targets);
|
|
//
|
|
// TP3: 1:3 R:R ...
|
|
XTarget tp3;
|
|
tp3.target = entry + (risk * 3);
|
|
tp3.volumeMultiplier = 1.0;
|
|
tp3.doRF = false;
|
|
tp3.doRFOnEntry = false;
|
|
AddRef(tp3, targets);
|
|
}
|
|
}
|
|
//
|
|
// Generate Bearish FVG Mitigation Signal ...
|
|
else if (isBearish)
|
|
{
|
|
dir = X_DIRECTION_BEARISH;
|
|
//
|
|
// Select Best FVG (Youngest Valid FVG in Mitigation) ...
|
|
XBoxZone selectedFVG;
|
|
int fvgIdx = GetYoungest(mitigatingBearishFVGs);
|
|
//
|
|
if (IsValidIndex(fvgIdx))
|
|
{
|
|
selectedFVG = mitigatingBearishFVGs[fvgIdx];
|
|
}
|
|
//
|
|
// Validate Selected FVG ...
|
|
if (selectedFVG.IsValid())
|
|
{
|
|
zone = selectedFVG;
|
|
zone.type = "S6_FVG_Mitigation";
|
|
//
|
|
// Calculate Targets ...
|
|
double entry = GetEntry(symbol, dir);
|
|
//
|
|
// SL: Above FVG Upper ...
|
|
double sl = zone.upper + (10 * points);
|
|
//
|
|
// TP1: 1:1 R:R ...
|
|
double risk = MathAbs(entry - sl);
|
|
XTarget tp1;
|
|
tp1.target = entry - risk;
|
|
tp1.volumeMultiplier = 0.5;
|
|
tp1.doRF = true;
|
|
tp1.doRFOnEntry = false;
|
|
AddRef(tp1, targets);
|
|
//
|
|
// TP2: Next Liquidity (Swing Low) ...
|
|
XTarget tp2;
|
|
if (swingLow.IsValid())
|
|
{
|
|
tp2.target = swingLow.lower - (10 * points);
|
|
}
|
|
else
|
|
{
|
|
tp2.target = entry - (risk * 2);
|
|
}
|
|
tp2.volumeMultiplier = 0.5;
|
|
tp2.doRF = false;
|
|
tp2.doRFOnEntry = false;
|
|
AddRef(tp2, targets);
|
|
//
|
|
// TP3: 1:3 R:R ...
|
|
XTarget tp3;
|
|
tp3.target = entry - (risk * 3);
|
|
tp3.volumeMultiplier = 1.0;
|
|
tp3.doRF = false;
|
|
tp3.doRFOnEntry = false;
|
|
AddRef(tp3, targets);
|
|
}
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 10. Validation & Risk Management ...
|
|
//
|
|
// Validate Signal ...
|
|
result = zone.IsValid() && HasDirection(dir) && HasChild(targets);
|
|
//
|
|
// Check Max Allowed Risk ...
|
|
if (result && maxAllowedRiskDistance > 0)
|
|
{
|
|
double riskInPoints = 0;
|
|
if (dir == X_DIRECTION_BULLISH)
|
|
{
|
|
riskInPoints = MathAbs(zone.GetDirectionalPrice() - zone.GetInDirectionalPrice()) / points;
|
|
}
|
|
else
|
|
{
|
|
riskInPoints = MathAbs(zone.GetInDirectionalPrice() - zone.GetDirectionalPrice()) / points;
|
|
}
|
|
//
|
|
if (riskInPoints > maxAllowedRiskDistance)
|
|
{
|
|
result = false;
|
|
zone.Clean();
|
|
XClean(targets);
|
|
dir = X_DIRECTION_NONE;
|
|
}
|
|
}
|
|
//
|
|
// #endregion
|
|
//
|
|
// #region 11. Debug & Logging ...
|
|
//
|
|
// Optional: Debug Break for Testing ...
|
|
// if (result)
|
|
// {
|
|
// Print("Strategy 6 FVG Mitigation Signal Detected:");
|
|
// Print(" Direction: ", ToXString(dir));
|
|
// Print(" Bullish Score: ", bullishScore);
|
|
// Print(" Bearish Score: ", bearishScore);
|
|
// Print(" FVG Type: ", zone.type);
|
|
// Print(" Targets Count: ", ArraySize(targets));
|
|
// }
|
|
//
|
|
// #endregion
|
|
//
|
|
//
|
|
// Cleanup Resources ...
|
|
//
|
|
XClean(bullishFVGs);
|
|
XClean(bearishFVGs);
|
|
XClean(validBullishFVGs);
|
|
XClean(validBearishFVGs);
|
|
XClean(mitigatingBullishFVGs);
|
|
XClean(mitigatingBearishFVGs);
|
|
//
|
|
return result;
|
|
}
|
|
```
|
|
|
|
## 📋 Helper Functions for FVG Mitigation
|
|
|
|
Add these helper functions to your signaller class:
|
|
|
|
```mql5
|
|
// #region FVG Helper Functions ...
|
|
/**
|
|
* Check if FVG is Filled or Not ...
|
|
*
|
|
* @param bar: XOHCL, Current Bar ...
|
|
* @param fvg: XBoxZone, FVG Zone ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsFVGFilled(
|
|
XOHCL &bar,
|
|
XBoxZone &fvg //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
//
|
|
// Validate ...
|
|
result = bar.IsValid() && fvg.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
//
|
|
// Check if FVG is Bullish or Bearish ...
|
|
bool isBullishFVG = fvg.IsBullish();
|
|
bool isBearishFVG = fvg.IsBearish();
|
|
//
|
|
// Check if Price has Filled the FVG ...
|
|
if (isBullishFVG)
|
|
{
|
|
//
|
|
// Bullish FVG is filled when price touches lower boundary ...
|
|
result = bar.low <= fvg.lower;
|
|
}
|
|
else if (isBearishFVG)
|
|
{
|
|
//
|
|
// Bearish FVG is filled when price touches upper boundary ...
|
|
result = bar.high >= fvg.upper;
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
/**
|
|
* Check if Price is Inside or Near FVG ...
|
|
*
|
|
* @param bar: XOHCL, Current Bar ...
|
|
* @param fvg: XBoxZone, FVG Zone ...
|
|
* @param tolerance: double, Tolerance in Points ...
|
|
*
|
|
* @return ( bool )
|
|
*/
|
|
bool IsPriceInFVG(
|
|
XOHCL &bar,
|
|
XBoxZone &fvg,
|
|
double tolerance = 0 //
|
|
)
|
|
{
|
|
//
|
|
bool result = false;
|
|
//
|
|
// Validate ...
|
|
result = bar.IsValid() && fvg.IsValid();
|
|
if (!result)
|
|
{
|
|
return result;
|
|
}
|
|
//
|
|
double points = GetPoints(bar.symbol);
|
|
double tolerancePrice = tolerance * points;
|
|
//
|
|
// Check if Price is Inside or Near FVG ...
|
|
bool isBullishFVG = fvg.IsBullish();
|
|
bool isBearishFVG = fvg.IsBearish();
|
|
//
|
|
if (isBullishFVG)
|
|
{
|
|
//
|
|
// Price is mitigating bullish FVG ...
|
|
result =
|
|
(bar.low <= fvg.upper + tolerancePrice) &&
|
|
(bar.high >= fvg.lower - tolerancePrice);
|
|
}
|
|
else if (isBearishFVG)
|
|
{
|
|
//
|
|
// Price is mitigating bearish FVG ...
|
|
result =
|
|
(bar.high >= fvg.lower - tolerancePrice) &&
|
|
(bar.low <= fvg.upper + tolerancePrice);
|
|
}
|
|
//
|
|
return result;
|
|
}
|
|
// #endregion
|
|
```
|
|
|
|
## 📊 Key Features of Strategy 6 (FVG Mitigation)
|
|
|
|
### **Entry Conditions:**
|
|
|
|
| Component | Weight | Description |
|
|
|-----------|--------|-------------|
|
|
| **FVG Mitigation** | 6 pts | Price returning to unmitigated FVG |
|
|
| **KI Trend Alignment** | 6 pts | KI Fast + Slow + SuperSlow alignment |
|
|
| **KI Wave Momentum** | 2 pts | KI Wave color switch confirmation |
|
|
| **RSI Confirmation** | 4 pts | RSI cross + Divergence detection |
|
|
| **Volatility** | 3 pts | ATR expansion confirmation |
|
|
| **FVG Quality** | 4 pts | FVG size validation (20-50+ points) |
|
|
| **Minimum Score** | 16 pts | Required for signal generation |
|
|
|
|
### **FVG Validation:**
|
|
|
|
```
|
|
✅ Minimum FVG Size: 20 points
|
|
✅ FVG Must Not Be Broken
|
|
✅ FVG Must Not Be Filled
|
|
✅ FVG Must Be Recent (within 50 bars)
|
|
✅ Price Must Be Mitigating FVG (within 10 points)
|
|
```
|
|
|
|
### **Risk Management:**
|
|
|
|
```mql5
|
|
// Stop Loss:
|
|
SL = Below/Above FVG edge ± 10 points buffer
|
|
|
|
// Take Profit Levels:
|
|
TP1 = 1:1 R:R (50% position, RF enabled)
|
|
TP2 = Next Swing Liquidity (50% position)
|
|
TP3 = 1:3 R:R (100% position)
|
|
```
|
|
|
|
### **Signal Filtering:**
|
|
|
|
1. ✅ **Valid FVG**: Minimum 20 points, not broken, not filled
|
|
2. ✅ **Mitigation**: Price must be inside or near FVG (10 points tolerance)
|
|
3. ✅ **Recent FVG**: Within 50 bars from formation
|
|
4. ✅ **KI Alignment**: At least KI Fast must align with direction
|
|
5. ✅ **Minimum Score**: 16 points (selective entries)
|
|
6. ✅ **FVG Quality**: Larger FVGs score higher (up to 4 points)
|
|
|
|
## 📊 Expected Behavior
|
|
|
|
### **Bullish FVG Mitigation Setup:**
|
|
1. **FVG Forms**: Bullish FVG created by strong upward move
|
|
2. **Price Retraces**: Price returns to FVG zone (mitigation)
|
|
3. **KI Confirms**: KI Fast turns Green, price above KI Fast
|
|
4. **RSI**: Shows bullish momentum or divergence
|
|
5. **Entry**: On close of confirmation candle in FVG zone
|
|
6. **Target**: Next swing high or 1:3 R:R
|
|
|
|
### **Bearish FVG Mitigation Setup:**
|
|
1. **FVG Forms**: Bearish FVG created by strong downward move
|
|
2. **Price Retraces**: Price returns to FVG zone (mitigation)
|
|
3. **KI Confirms**: KI Fast turns Red, price below KI Fast
|
|
4. **RSI**: Shows bearish momentum or divergence
|
|
5. **Entry**: On close of confirmation candle in FVG zone
|
|
6. **Target**: Next swing low or 1:3 R:R
|
|
|
|
## ⚠️ Important Notes
|
|
|
|
1. **FVG Mitigation works best in trending markets** - Avoid using in choppy/ranging conditions
|
|
2. **Wait for mitigation** - Don't enter before price touches FVG zone
|
|
3. **FVG Quality matters** - Larger FVGs (50+ points) have higher success rate
|
|
4. **Recent FVGs preferred** - FVGs within 50 bars score higher
|
|
5. **Higher minimum score** - 16 points vs 15 for other strategies (more selective)
|
|
6. **Best timeframes**: M15, M30, H1, H4 for FVG detection
|
|
|
|
## 📈 Performance Expectations
|
|
|
|
| Metric | Expected Value |
|
|
|--------|---------------|
|
|
| **Win Rate** | 60-70% |
|
|
| **Frequency** | 2-5 signals per week |
|
|
| **R:R** | 1:3 average |
|
|
| **Best Session** | London/NY Overlap |
|
|
| **Best Pairs** | EURUSD, GBPUSD, XAUUSD, US30 |
|