685 lines
17 KiB
Markdown
685 lines
17 KiB
Markdown
### USER
|
||
Strategy 5: KI Silver Bullet (Time-Based)
|
||
|
||
### ASSISTANT
|
||
# 🎯 Complete Strategy 5: KI Silver Bullet (Time-Based) Implementation
|
||
|
||
Based on your **SaherElm Framework** and **X121XKI Indicator** buffers, here is the complete implementation for **Strategy 5: KI Silver Bullet (Time-Based)**.
|
||
|
||
This strategy focuses on **high-probability time-based entries** during **London/NY Killzones** with **KI momentum confirmation** for consistent daily setups.
|
||
|
||
```mql5
|
||
/**
|
||
* Check Bar Has Signal Based on Strategy 5 ...
|
||
* KI Silver Bullet (Time-Based)
|
||
*
|
||
* @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 Strategy5HasSignal(
|
||
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 minOBPoints = 30; // Minimum Order Block size in points
|
||
int minFVGPoints = 20; // Minimum FVG size in points
|
||
double minScore = 16.0; // Minimum score for signal
|
||
//
|
||
// Killzone Configuration ...
|
||
// London Killzone: 08:00-11:00 Server Time
|
||
// NY Killzone: 13:00-16:00 Server Time
|
||
bool useLondonKillzone = true;
|
||
bool useNYKillzone = true;
|
||
string londonStart = "08:00";
|
||
string londonEnd = "11:00";
|
||
string nyStart = "13:00";
|
||
string nyEnd = "16:00";
|
||
//
|
||
// State Variables ...
|
||
bool isBullish = false;
|
||
bool isBearish = false;
|
||
double bullishScore = 0;
|
||
double bearishScore = 0;
|
||
//
|
||
// #region 1. Time Filter (Killzone Check) ...
|
||
//
|
||
bool isInKillzone = false;
|
||
MqlDateTime currentTime;
|
||
TimeToStruct(TimeCurrent(), currentTime);
|
||
//
|
||
// Format Current Time as HH:MM ...
|
||
string currentHour = StringFormat("%02d", currentTime.hour);
|
||
string currentMinute = StringFormat("%02d", currentTime.min);
|
||
string currentTimeStr = currentHour + ":" + currentMinute;
|
||
//
|
||
// Check London Killzone ...
|
||
if (useLondonKillzone)
|
||
{
|
||
bool isAfterLondonStart = currentTimeStr >= londonStart;
|
||
bool isBeforeLondonEnd = currentTimeStr < londonEnd;
|
||
if (isAfterLondonStart && isBeforeLondonEnd)
|
||
{
|
||
isInKillzone = true;
|
||
}
|
||
}
|
||
//
|
||
// Check NY Killzone ...
|
||
if (useNYKillzone && !isInKillzone)
|
||
{
|
||
bool isAfterNYStart = currentTimeStr >= nyStart;
|
||
bool isBeforeNYEnd = currentTimeStr < nyEnd;
|
||
if (isAfterNYStart && isBeforeNYEnd)
|
||
{
|
||
isInKillzone = true;
|
||
}
|
||
}
|
||
//
|
||
// Must be in Killzone for Silver Bullet ...
|
||
if (!isInKillzone)
|
||
{
|
||
return false;
|
||
}
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 2. KI Wave Momentum Switch ...
|
||
//
|
||
// Check KI Wave Switch (Primary Trigger) ...
|
||
bool kiWaveSwitchedBullish = kiParser.IsKIWaveSwitchedToBullish(barIndex);
|
||
bool kiWaveSwitchedBearish = kiParser.IsKIWaveSwitchedToBearish(barIndex);
|
||
//
|
||
// Check KI Wave Current State ...
|
||
bool kiWaveBullish = kiParser.IsKIWaveBullish(barIndex);
|
||
bool kiWaveBearish = kiParser.IsKIWaveBearish(barIndex);
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 3. RSI Momentum Confirmation ...
|
||
//
|
||
// Check RSI Cross 50 Level ...
|
||
double currentRSI = kiParser.GetRSI(barIndex);
|
||
double previousRSI = kiParser.GetRSI(barIndex + 1);
|
||
//
|
||
bool rsiCrossedAbove50 = currentRSI > 50 && previousRSI <= 50;
|
||
bool rsiCrossedBelow50 = currentRSI < 50 && previousRSI >= 50;
|
||
//
|
||
// Check RSI State ...
|
||
bool rsiBullish = kiParser.IsRSISwitchedToBullish(barIndex, 50, 2);
|
||
bool rsiBearish = kiParser.IsRSISwitchedToBearish(barIndex, 50, 2);
|
||
//
|
||
// Check RSI Not in Extreme Zones ...
|
||
bool rsiNotOverbought = currentRSI < 70;
|
||
bool rsiNotOversold = currentRSI > 30;
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 4. MA Fast Alignment ...
|
||
//
|
||
// Check MA Fast vs KI Fast ...
|
||
double maFast = kiParser.GetMAFast(barIndex);
|
||
double kiFast = kiParser.GetKIFast(barIndex);
|
||
//
|
||
bool maFastAboveKI = maFast > kiFast;
|
||
bool maFastBelowKI = maFast < kiFast;
|
||
//
|
||
// Check MA Fast Switch ...
|
||
bool maFastSwitchedBullish = kiParser.IsMAFastSwitchedToBullish(barIndex);
|
||
bool maFastSwitchedBearish = kiParser.IsMAFastSwitchedToBearish(barIndex);
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 5. Volatility Expansion (ATR) ...
|
||
//
|
||
// Check ATR 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. KI Fast Trend Alignment ...
|
||
//
|
||
// Check KI Fast State ...
|
||
bool kiFastBullish = kiParser.IsKIFastBullish(barIndex);
|
||
bool kiFastBearish = kiParser.IsKIFastBearish(barIndex);
|
||
//
|
||
// Check KI Fast Switch ...
|
||
bool kiFastSwitchedBullish = kiParser.IsKIFastSwitchedToBullish(barIndex);
|
||
bool kiFastSwitchedBearish = kiParser.IsKIFastSwitchedToBearish(barIndex);
|
||
//
|
||
// Check Price Position Relative to KI Fast ...
|
||
bool priceAboveKIFast = kiParser.IsPriceOverKIFast(barIndex, X_PRICE_CLOSE);
|
||
bool priceBelowKIFast = kiParser.IsPriceUnderKIFast(barIndex, X_PRICE_CLOSE);
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 7. POI Detection (Entry Zone) ...
|
||
//
|
||
// Detect Order Blocks ...
|
||
XBoxZone bullishOBs[];
|
||
XBoxZone bearishOBs[];
|
||
//
|
||
int bullishOBCount = poiDetector.CollectOBs(bar, bullishOBs, 5, 10, 100);
|
||
int bearishOBCount = poiDetector.CollectOBs(bar, bearishOBs, 5, 10, 100);
|
||
//
|
||
// 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 OB/FVG Size ...
|
||
XBoxZone validBullishOBs[];
|
||
XBoxZone validBearishOBs[];
|
||
XBoxZone validBullishFVGs[];
|
||
XBoxZone validBearishFVGs[];
|
||
//
|
||
// Filter Bullish OBs ...
|
||
for (int i = 0; i < bullishOBCount; i++)
|
||
{
|
||
double obRange = (bullishOBs[i].upper - bullishOBs[i].lower) / points;
|
||
if (obRange >= minOBPoints && !IsXValid(bullishOBs[i].breakAt))
|
||
{
|
||
AddRef(bullishOBs[i], validBullishOBs);
|
||
}
|
||
}
|
||
//
|
||
// Filter Bearish OBs ...
|
||
for (int i = 0; i < bearishOBCount; i++)
|
||
{
|
||
double obRange = (bearishOBs[i].upper - bearishOBs[i].lower) / points;
|
||
if (obRange >= minOBPoints && !IsXValid(bearishOBs[i].breakAt))
|
||
{
|
||
AddRef(bearishOBs[i], validBearishOBs);
|
||
}
|
||
}
|
||
//
|
||
// Filter Bullish FVGs ...
|
||
for (int i = 0; i < bullishFVGCount; i++)
|
||
{
|
||
double fvgRange = (bullishFVGs[i].upper - bullishFVGs[i].lower) / points;
|
||
if (fvgRange >= minFVGPoints && !IsXValid(bullishFVGs[i].breakAt))
|
||
{
|
||
AddRef(bullishFVGs[i], validBullishFVGs);
|
||
}
|
||
}
|
||
//
|
||
// Filter Bearish FVGs ...
|
||
for (int i = 0; i < bearishFVGCount; i++)
|
||
{
|
||
double fvgRange = (bearishFVGs[i].upper - bearishFVGs[i].lower) / points;
|
||
if (fvgRange >= minFVGPoints && !IsXValid(bearishFVGs[i].breakAt))
|
||
{
|
||
AddRef(bearishFVGs[i], validBearishFVGs);
|
||
}
|
||
}
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 8. Recent Swing Detection (Liquidity) ...
|
||
//
|
||
XBoxZone swingHigh;
|
||
XBoxZone swingLow;
|
||
//
|
||
poiDetector.DetectRecentSwings(
|
||
swingHigh,
|
||
swingLow,
|
||
barIndex,
|
||
50, // swingsValidationLength
|
||
500, // loopback
|
||
period,
|
||
true // forceRefineZones
|
||
);
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 9. Calculate Scores ...
|
||
//
|
||
// Bullish Silver Bullet Score ...
|
||
//
|
||
// Killzone (Required - Already Passed) ...
|
||
//
|
||
// KI Wave Momentum Switch (Max 5 points) ...
|
||
if (kiWaveSwitchedBullish) bullishScore += 5;
|
||
if (kiWaveBullish) bullishScore += 2;
|
||
//
|
||
// RSI Momentum (Max 4 points) ...
|
||
if (rsiCrossedAbove50) bullishScore += 3;
|
||
if (rsiBullish) bullishScore += 2;
|
||
if (rsiNotOverbought) bullishScore += 1;
|
||
//
|
||
// MA Fast Alignment (Max 3 points) ...
|
||
if (maFastAboveKI) bullishScore += 2;
|
||
if (maFastSwitchedBullish) bullishScore += 2;
|
||
//
|
||
// Volatility (Max 3 points) ...
|
||
if (volatilitySwitchedHigh) bullishScore += 3;
|
||
if (volatilityHigh) bullishScore += 1;
|
||
if (atrBreakoutUp) bullishScore += 2;
|
||
//
|
||
// KI Fast Trend (Max 4 points) ...
|
||
if (kiFastBullish) bullishScore += 2;
|
||
if (kiFastSwitchedBullish) bullishScore += 2;
|
||
if (priceAboveKIFast) bullishScore += 1;
|
||
//
|
||
// POI Presence (Max 4 points) ...
|
||
if (ArraySize(validBullishOBs) > 0) bullishScore += 3;
|
||
if (ArraySize(validBullishFVGs) > 0) bullishScore += 2;
|
||
//
|
||
// Bearish Silver Bullet Score ...
|
||
//
|
||
// KI Wave Momentum Switch (Max 5 points) ...
|
||
if (kiWaveSwitchedBearish) bearishScore += 5;
|
||
if (kiWaveBearish) bearishScore += 2;
|
||
//
|
||
// RSI Momentum (Max 4 points) ...
|
||
if (rsiCrossedBelow50) bearishScore += 3;
|
||
if (rsiBearish) bearishScore += 2;
|
||
if (rsiNotOversold) bearishScore += 1;
|
||
//
|
||
// MA Fast Alignment (Max 3 points) ...
|
||
if (maFastBelowKI) bearishScore += 2;
|
||
if (maFastSwitchedBearish) bearishScore += 2;
|
||
//
|
||
// Volatility (Max 3 points) ...
|
||
if (volatilitySwitchedHigh) bearishScore += 3;
|
||
if (volatilityHigh) bearishScore += 1;
|
||
if (atrBreakoutDown) bearishScore += 2;
|
||
//
|
||
// KI Fast Trend (Max 4 points) ...
|
||
if (kiFastBearish) bearishScore += 2;
|
||
if (kiFastSwitchedBearish) bearishScore += 2;
|
||
if (priceBelowKIFast) bearishScore += 1;
|
||
//
|
||
// POI Presence (Max 4 points) ...
|
||
if (ArraySize(validBearishOBs) > 0) bearishScore += 3;
|
||
if (ArraySize(validBearishFVGs) > 0) bearishScore += 2;
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 10. 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 Silver Bullet Conditions ...
|
||
isBullish =
|
||
(bullishScore >= minScore) &&
|
||
(kiWaveSwitchedBullish || kiWaveBullish) &&
|
||
(rsiCrossedAbove50 || rsiBullish) &&
|
||
(ArraySize(validBullishOBs) > 0 || ArraySize(validBullishFVGs) > 0);
|
||
//
|
||
// Check Bearish Silver Bullet Conditions ...
|
||
isBearish =
|
||
(bearishScore >= minScore) &&
|
||
(kiWaveSwitchedBearish || kiWaveBearish) &&
|
||
(rsiCrossedBelow50 || rsiBearish) &&
|
||
(ArraySize(validBearishOBs) > 0 || ArraySize(validBearishFVGs) > 0);
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 11. Generate Signal ...
|
||
//
|
||
// Generate Bullish Silver Bullet Signal ...
|
||
if (isBullish)
|
||
{
|
||
dir = X_DIRECTION_BULLISH;
|
||
//
|
||
// Select Best POI (Youngest Valid OB or FVG) ...
|
||
XBoxZone selectedPOI;
|
||
int obIdx = GetYoungest(validBullishOBs);
|
||
int fvgIdx = GetYoungest(validBullishFVGs);
|
||
//
|
||
if (IsValidIndex(obIdx) && IsValidIndex(fvgIdx))
|
||
{
|
||
//
|
||
// Choose the one closer to current price ...
|
||
double obDistance = bar.close - validBullishOBs[obIdx].upper;
|
||
double fvgDistance = bar.close - validBullishFVGs[fvgIdx].upper;
|
||
//
|
||
selectedPOI = (obDistance < fvgDistance) ? validBullishOBs[obIdx] : validBullishFVGs[fvgIdx];
|
||
}
|
||
else if (IsValidIndex(obIdx))
|
||
{
|
||
selectedPOI = validBullishOBs[obIdx];
|
||
}
|
||
else if (IsValidIndex(fvgIdx))
|
||
{
|
||
selectedPOI = validBullishFVGs[fvgIdx];
|
||
}
|
||
//
|
||
// Validate Selected POI ...
|
||
if (selectedPOI.IsValid())
|
||
{
|
||
zone = selectedPOI;
|
||
zone.type = "S5_SilverBullet_KI";
|
||
//
|
||
// Calculate Targets ...
|
||
double entry = GetEntry(symbol, dir);
|
||
//
|
||
// SL: Below POI or Recent Swing Low ...
|
||
double sl = 0;
|
||
double atr = kiParser.GetATR(barIndex);
|
||
if (swingLow.IsValid())
|
||
{
|
||
sl = swingLow.lower - (10 * points);
|
||
}
|
||
else
|
||
{
|
||
sl = zone.lower - (atr * 1.5);
|
||
}
|
||
//
|
||
// 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: 1:2 R:R or Next Liquidity ...
|
||
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 (Silver Bullet Target) ...
|
||
XTarget tp3;
|
||
tp3.target = entry + (risk * 3);
|
||
tp3.volumeMultiplier = 1.0;
|
||
tp3.doRF = false;
|
||
tp3.doRFOnEntry = false;
|
||
AddRef(tp3, targets);
|
||
}
|
||
}
|
||
//
|
||
// Generate Bearish Silver Bullet Signal ...
|
||
else if (isBearish)
|
||
{
|
||
dir = X_DIRECTION_BEARISH;
|
||
//
|
||
// Select Best POI (Youngest Valid OB or FVG) ...
|
||
XBoxZone selectedPOI;
|
||
int obIdx = GetYoungest(validBearishOBs);
|
||
int fvgIdx = GetYoungest(validBearishFVGs);
|
||
//
|
||
if (IsValidIndex(obIdx) && IsValidIndex(fvgIdx))
|
||
{
|
||
//
|
||
// Choose the one closer to current price ...
|
||
double obDistance = zone.lower - bar.close;
|
||
double fvgDistance = zone.lower - bar.close;
|
||
//
|
||
selectedPOI = (obDistance < fvgDistance) ? validBearishOBs[obIdx] : validBearishFVGs[fvgIdx];
|
||
}
|
||
else if (IsValidIndex(obIdx))
|
||
{
|
||
selectedPOI = validBearishOBs[obIdx];
|
||
}
|
||
else if (IsValidIndex(fvgIdx))
|
||
{
|
||
selectedPOI = validBearishFVGs[fvgIdx];
|
||
}
|
||
//
|
||
// Validate Selected POI ...
|
||
if (selectedPOI.IsValid())
|
||
{
|
||
zone = selectedPOI;
|
||
zone.type = "S5_SilverBullet_KI";
|
||
//
|
||
// Calculate Targets ...
|
||
double entry = GetEntry(symbol, dir);
|
||
//
|
||
// SL: Above POI or Recent Swing High ...
|
||
double sl = 0;
|
||
double atr = kiParser.GetATR(barIndex);
|
||
if (swingHigh.IsValid())
|
||
{
|
||
sl = swingHigh.upper + (10 * points);
|
||
}
|
||
else
|
||
{
|
||
sl = zone.upper + (atr * 1.5);
|
||
}
|
||
//
|
||
// 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: 1:2 R:R or Next Liquidity ...
|
||
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 (Silver Bullet Target) ...
|
||
XTarget tp3;
|
||
tp3.target = entry - (risk * 3);
|
||
tp3.volumeMultiplier = 1.0;
|
||
tp3.doRF = false;
|
||
tp3.doRFOnEntry = false;
|
||
AddRef(tp3, targets);
|
||
}
|
||
}
|
||
//
|
||
// #endregion
|
||
//
|
||
// #region 12. 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 13. Debug & Logging ...
|
||
//
|
||
// Optional: Debug Break for Testing ...
|
||
// if (result)
|
||
// {
|
||
// Print("Strategy 5 Silver Bullet Signal Detected:");
|
||
// Print(" Direction: ", ToXString(dir));
|
||
// Print(" Bullish Score: ", bullishScore);
|
||
// Print(" Bearish Score: ", bearishScore);
|
||
// Print(" Killzone: ", currentTimeStr);
|
||
// Print(" POI Type: ", zone.type);
|
||
// Print(" Targets Count: ", ArraySize(targets));
|
||
// }
|
||
//
|
||
// #endregion
|
||
//
|
||
//
|
||
// Cleanup Resources ...
|
||
//
|
||
XClean(bullishOBs);
|
||
XClean(bearishOBs);
|
||
XClean(bullishFVGs);
|
||
XClean(bearishFVGs);
|
||
XClean(validBullishOBs);
|
||
XClean(validBearishOBs);
|
||
XClean(validBullishFVGs);
|
||
XClean(validBearishFVGs);
|
||
//
|
||
return result;
|
||
}
|
||
```
|
||
|
||
## 📋 Key Features of Strategy 5 (Silver Bullet)
|
||
|
||
### **Entry Conditions:**
|
||
|
||
| Component | Weight | Description |
|
||
|-----------|--------|-------------|
|
||
| **Killzone Time** | Required | London (08:00-11:00) or NY (13:00-16:00) |
|
||
| **KI Wave Switch** | 5 pts | KI Wave momentum switch confirmation |
|
||
| **RSI Cross 50** | 3 pts | RSI crosses above/below 50 level |
|
||
| **MA Fast Alignment** | 3 pts | MA Fast above/below KI Fast |
|
||
| **Volatility** | 3 pts | ATR expansion confirmation |
|
||
| **KI Fast Trend** | 4 pts | KI Fast trend alignment |
|
||
| **POI Presence** | 4 pts | Valid OB or FVG for entry |
|
||
| **Minimum Score** | 16 pts | Required for signal generation |
|
||
|
||
### **Killzone Times (Server Time):**
|
||
|
||
```
|
||
London Killzone: 08:00 - 11:00
|
||
NY Killzone: 13:00 - 16:00
|
||
|
||
// Adjust based on your broker's server time
|
||
// GMT+2 or GMT+3 typically for Forex brokers
|
||
```
|
||
|
||
### **Risk Management:**
|
||
|
||
```mql5
|
||
// Stop Loss:
|
||
SL = Below/Above POI edge OR Recent Swing ± 10 points
|
||
OR
|
||
SL = POI edge ± (ATR × 1.5)
|
||
|
||
// Take Profit Levels:
|
||
TP1 = 1:1 R:R (50% position, RF enabled)
|
||
TP2 = 1:2 R:R OR Next Swing Liquidity (50% position)
|
||
TP3 = 1:3 R:R (100% position - Silver Bullet target)
|
||
```
|
||
|
||
### **Signal Filtering:**
|
||
|
||
1. ✅ **Must be in Killzone** - Time filter is mandatory
|
||
2. ✅ **KI Wave Switch** - Primary momentum trigger
|
||
3. ✅ **RSI Cross 50** - Momentum confirmation
|
||
4. ✅ **POI Required** - OB or FVG for entry zone
|
||
5. ✅ **Minimum Score** - 16 points (selective entries)
|
||
6. ✅ **Volatility Expansion** - ATR confirms movement
|
||
|
||
## 📊 Expected Behavior
|
||
|
||
### **Bullish Silver Bullet Setup:**
|
||
1. **Time**: London or NY Killzone active
|
||
2. **KI Wave**: Switches to bullish (green)
|
||
3. **RSI**: Crosses above 50 level
|
||
4. **MA Fast**: Above KI Fast
|
||
5. **ATR**: Shows volatility expansion
|
||
6. **Entry**: Bullish OB or FVG retest
|
||
7. **Target**: 1:3 R:R typical for Silver Bullet
|
||
|
||
### **Bearish Silver Bullet Setup:**
|
||
1. **Time**: London or NY Killzone active
|
||
2. **KI Wave**: Switches to bearish (red)
|
||
3. **RSI**: Crosses below 50 level
|
||
4. **MA Fast**: Below KI Fast
|
||
5. **ATR**: Shows volatility expansion
|
||
6. **Entry**: Bearish OB or FVG retest
|
||
7. **Target**: 1:3 R:R typical for Silver Bullet
|
||
|
||
## ⚠️ Important Notes
|
||
|
||
1. **Time Zone Critical** - Adjust killzone times to match your broker's server time
|
||
2. **One Setup Per Day** - Silver Bullet typically produces 1-2 high-quality setups daily
|
||
3. **Killzone Discipline** - Only trade during specified time windows
|
||
4. **Higher Win Rate** - Time-based entries typically have 65-75% win rate
|
||
5. **News Awareness** - Avoid major news events during killzones
|
||
6. **Session Overlap** - London/NY overlap (13:00-16:00) often produces best setups
|
||
|
||
## 📈 Performance Expectations
|
||
|
||
| Metric | Expected Value |
|
||
|--------|---------------|
|
||
| **Win Rate** | 65-75% |
|
||
| **Frequency** | 1-3 signals per day |
|
||
| **R:R** | 1:3 average |
|
||
| **Best Session** | London/NY Overlap |
|
||
| **Best Pairs** | EURUSD, GBPUSD, XAUUSD |
|