### 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 |