/////////////////////////////////////////////////////// // // SaherElm IT Center MQL5 X121 SMC Signal Class // ------------------------------------------------- // Name: X // Description: provide all Signalling functions ... // // // Maintainer: // ------------ // Hadi Khazaee Asl (hadi_khazaee_asl@yahoo.com) // ////////////////////////////////////////////////////// // // Global Properties ... #property library #property copyright "Copyright 2023, SaherElm IT Center" #property link "https://www.saherelm.ir" #property version "1.00" #property strict // // Imports ... // #include "../../Libraries/x-trade.lib" #include "../Classes/x-121.smc.market.cycle.helper.class.mq5" #include "../Libraries/x-121.smc.lib.mq5" // // Definitions ... struct X121SMCStrategyXPVTSignalConditions { // // Props ... // string symbol; ENUM_TIMEFRAMES period; // double sl; double target; ENUM_X_DIRECTION dir; ENUM_X_POSITION_TYPES type; // // Setup Props ... // datetime setupTime; datetime triggerTime; // double pivot; double point; // double peak; datetime peakTime; // double higherPeak; datetime higherPeakTime; // double vale; datetime valeTime; // double lowerVale; datetime lowerValeTime; // ENUM_XPV_PIVOTS pvType; // XPVPivot pivotZone; // // Constructor ... X121SMCStrategyXPVTSignalConditions() { Clean(); } // // Tools ... /** * Cleaning Up ... */ void Clean() { // sl = 0; target = 0; // dir = X_DIRECTION_NONE; type = X_POSITION_TYPE_NONE; // symbol = NULL; period = NULL; setupTime = NULL; triggerTime = NULL; // ExtensionClean(); } /** * Check Condition is Setting Up ... * * @param dir: ENUM_X_DIRECTION member, Setting Up Direction ... * * @return ( bool ) */ bool IsSetuped() { // bool result = false; // result = IsValid(setupTime) && HasDirection(dir); if (!result) { return result; } // return result; } /** * Calculate Setup Age ... * * @return ( int ) */ int GetSetupAge() { // int result = 0; // if (!IsSetuped()) { return result; } // result = (int)(TimeCurrent() - setupTime) / PeriodSeconds(period); // return result; } /** * Detect How we Can Trigger Signal ... * * @return ( bool ) */ bool CanTrigger() { // bool result = false; // result = // sl > 0 && IsValid(symbol) && IsValid(period) && IsValid(triggerTime) && type != X_POSITION_TYPE_ALL && type != X_POSITION_TYPE_NONE // ; // return result; } // // Extensions ... /** * Clean Additional Properties ... */ void ExtensionClean() { // pivot = 0; point = 0; // pvType = XPV_NONE; // peak = 0; peakTime = NULL; // higherPeak = 0; higherPeakTime = NULL; // vale = 0; valeTime = NULL; // lowerVale = 0; lowerValeTime = NULL; // pivotZone.Clean(); } // bool HasPeak() { // bool result = false; // result = peak > 0 && IsValid(peakTime); // return result; } // bool HasHigherPeak() { // bool result = false; // result = higherPeak > 0 && IsValid(higherPeakTime); // return result; } // bool HasVale() { // bool result = false; // result = vale > 0 && IsValid(valeTime); // return result; } // bool HasLowerVale() { // bool result = false; // result = lowerVale > 0 && IsValid(lowerValeTime); // return result; } // }; // // Signaller Data Sources ... X121SMCStrategyXPVTSignalConditions mXPVTConditions; X121SMCStrategyXPVTSignalConditions mXPVTConditionsCollection[]; // // Extension Functions ... // // Detect Setup Conditions ... bool DetectX121SMCXPVTSiganlSetup( string _symbol, ENUM_TIMEFRAMES _period, // X121SMCStrategyXPVTSignalConditions &conditions, // XC121SMCCycleHelper *triggerCycleHelper, XC121SMCCycleHelper *decisionCycleHelper, XC121SMCCycleHelper *analyseCycleHelper, XC121SMCCycleHelper *verificationCycleHelper, XC121SMCCycleHelper *consolidationCycleHelper, XC121SMCCycleHelper *visionCycleHelper // ) { // bool result = false; // bool isBullish = false; bool isBearish = false; // int zIndex = 0; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // int loopback = 10; // string symbol = _symbol; ENUM_TIMEFRAMES period = _period; // conditions.symbol = symbol; conditions.period = period; // XOHCL zBar; result = decisionCycleHelper.GetBar( zBar, zIndex // ); // zBar.Init( // symbol, // period, // zIndex // // ); if (!result) { return result; } // XOHCL cBar; result = decisionCycleHelper.GetBar( cBar, cIndex // ); // cBar.Init( // symbol, // period, // cIndex // // ); if (!result) { return result; } // XOHCL pBar; result = decisionCycleHelper.GetBar( pBar, pIndex // ); // pBar.Init( // symbol, // period, // pIndex // // ); if (!result) { return result; } // double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); double points = GetPoints(symbol); // int swingLoopback = 3; double ll = cBar.FindLowest(swingLoopback, MODE_LOW); double hh = cBar.FindHighest(swingLoopback, MODE_HIGH); double llDown = cBar.FindLowesttDown(swingLoopback); double hhUp = cBar.FindHighestUp(swingLoopback); // // Cycles Conditions ... // // Trigger ... ENUM_XPOI_EVENTS triggerPoiEvents[]; ENUM_X_CYCLE_EVENTS triggerCycleEvents[]; X121SMCCycleConditions triggerConditions; result = triggerCycleHelper.GetConditions( triggerCycleEvents, triggerPoiEvents, triggerConditions, zIndex, loopback // ); if (!result) { return result; } // // Decision ... ENUM_XPOI_EVENTS decisionPoiEvents[]; ENUM_X_CYCLE_EVENTS decisionCycleEvents[]; X121SMCCycleConditions decisionConditions; result = decisionCycleHelper.GetConditions( decisionCycleEvents, decisionPoiEvents, decisionConditions, zIndex, loopback // ); if (!result) { return result; } // // Analyse ... ENUM_XPOI_EVENTS analysePoiEvents[]; ENUM_X_CYCLE_EVENTS analyseCycleEvents[]; X121SMCCycleConditions analyseConditions; result = analyseCycleHelper.GetConditions( analyseCycleEvents, analysePoiEvents, analyseConditions, zIndex, loopback // ); if (!result) { return result; } // // Verification ... ENUM_XPOI_EVENTS verificationPoiEvents[]; ENUM_X_CYCLE_EVENTS verificationCycleEvents[]; X121SMCCycleConditions verificationConditions; result = verificationCycleHelper.GetConditions( verificationCycleEvents, verificationPoiEvents, verificationConditions, zIndex, loopback // ); if (!result) { return result; } // // Consolidation ... ENUM_XPOI_EVENTS consolidationPoiEvents[]; ENUM_X_CYCLE_EVENTS consolidationCycleEvents[]; X121SMCCycleConditions consolidationConditions; result = consolidationCycleHelper.GetConditions( consolidationCycleEvents, consolidationPoiEvents, consolidationConditions, zIndex, loopback // ); if (!result) { return result; } // // Vision ... ENUM_XPOI_EVENTS visionPoiEvents[]; ENUM_X_CYCLE_EVENTS visionCycleEvents[]; X121SMCCycleConditions visionConditions; result = visionCycleHelper.GetConditions( visionCycleEvents, visionPoiEvents, visionConditions, zIndex, loopback // ); if (!result) { return result; } // // Cycles POI States ... XPOIState triggerState = triggerConditions.state; XPOIState decisionState = decisionConditions.state; XPOIState analyseState = analyseConditions.state; XPOIState verificationState = verificationConditions.state; XPOIState consolidationState = consolidationConditions.state; XPOIState visionState = visionConditions.state; // // Cycle X121Conditions ... X121Conditions triggerXConditions = triggerConditions.x121Conditions; X121Conditions decisionXConditions = decisionConditions.x121Conditions; X121Conditions analyseXConditions = analyseConditions.x121Conditions; X121Conditions verificationXConditions = verificationConditions.x121Conditions; X121Conditions consolidationXConditions = consolidationConditions.x121Conditions; X121Conditions visionXConditions = visionConditions.x121Conditions; // // Setup Conditions ... // // Detect Trend ... // // Consolidation ... ENUM_X_DIRECTION consolidationTrendDir; bool hasConsolidationTrend = consolidationCycleHelper .DetectMarketStructure( consolidationTrendDir // ); bool hasConsolidationBullishTrend = hasConsolidationTrend && IsBullish(consolidationTrendDir); bool hasConsolidationBearishTrend = hasConsolidationTrend && IsBearish(consolidationTrendDir); // // Verification ... ENUM_X_DIRECTION verificationTrendDir; bool hasVerificationTrend = verificationCycleHelper .DetectMarketStructure( verificationTrendDir // ); bool hasVerificationBullishTrend = hasVerificationTrend && IsBullish(verificationTrendDir); bool hasVerificationBearishTrend = hasVerificationTrend && IsBearish(verificationTrendDir); // // Analyse ... ENUM_X_DIRECTION analyseTrendDir; bool hasAnalyseTrend = analyseCycleHelper .DetectMarketStructure( analyseTrendDir // ); bool hasAnalyseBullishTrend = hasAnalyseTrend && IsBullish(analyseTrendDir); bool hasAnalyseBearishTrend = hasAnalyseTrend && IsBearish(analyseTrendDir); // // Decision ... ENUM_X_DIRECTION decisionTrendDir; bool hasDecisionTrend = decisionCycleHelper .DetectMarketStructure( decisionTrendDir // ); bool hasDecisionBullishTrend = hasDecisionTrend && IsBullish(decisionTrendDir); bool hasDecisionBearishTrend = hasDecisionTrend && IsBearish(decisionTrendDir); // // Detect Bar State ... // // PinBar ... ENUM_X_DIRECTION cBarPinDir; bool isCBarPin = decisionCycleHelper .mBarAnalyser .IsPinBar( cBar, cBarPinDir, 1 // ); bool isCBarBullishPin = isCBarPin && IsBullish(cBarPinDir); bool isCBarBearishPin = isCBarPin && IsBearish(cBarPinDir); // // Engulf ... ENUM_X_DIRECTION cBarEngulfDir; bool isCBarEngulfed = decisionCycleHelper .mBarAnalyser .IsEngulfBar( cBar, cBarEngulfDir, 0 // Extended ... ); bool isCBarBullishEngulfed = isCBarEngulfed && IsBullish(cBarEngulfDir); bool isCBarBearishEngulfed = isCBarEngulfed && IsBearish(cBarEngulfDir); // // Momentum ... ENUM_X_DIRECTION cBarMomentumDir; bool isCBarMomentum = decisionCycleHelper .mBarAnalyser .IsMomentumBar( cBar, cBarMomentumDir, 0 // Extended ... ); bool isCBarBullishMomentum = isCBarMomentum && IsBullish(cBarMomentumDir); bool isCBarBearishMomentum = isCBarMomentum && IsBearish(cBarMomentumDir); // // Reject ... ENUM_X_DIRECTION cBarRejectDir; bool isCBarRejected = decisionCycleHelper .mBarAnalyser .IsRejectionBar( cBar, cBarRejectDir, 0 // Extended ... ); bool isCBarBullishRejected = isCBarRejected && IsBullish(cBarRejectDir); bool isCBarBearishRejected = isCBarRejected && IsBearish(cBarRejectDir); // // Pull Back ... ENUM_X_DIRECTION cBarPullbackDir; bool isCBarPullbacked = decisionCycleHelper .mBarAnalyser .HasPullBack( cBarPullbackDir, cBar // ); bool isCBarBullishPullbacked = isCBarPullbacked && IsBullish(cBarPullbackDir); bool isCBarBearishPullbacked = isCBarPullbacked && IsBearish(cBarPullbackDir); // // HH/LL Break ... // bool isCBarBreaksUpHH = IsBarBreak( hh, X_DIRECTION_BULLISH, cBar // ); // bool isCBarBreaksDownLL = IsBarBreak( hh, X_DIRECTION_BEARISH, cBar // ); // // Bars Pattern and Power and Pressures ... // bool hasCBarBullishPattern = decisionCycleHelper .mBarAnalyser .HasBullishPattern( cBar, 2 // ); // bool hasCBarBearishPattern = decisionCycleHelper .mBarAnalyser .HasBearishPattern( cBar, 2 // ); // bool isCBarHasBullishPower = decisionCycleHelper .mBarAnalyser .HasBullishPower( cBar, 2 // ); // bool isCBarHasBearishPower = decisionCycleHelper .mBarAnalyser .HasBearishPower( cBar, 2 // ); // bool isCBarHasBullishPressure = decisionCycleHelper .mBarAnalyser .HasBullishPressure( cBar, 2 // ); // bool isCBarHasBearishPressure = decisionCycleHelper .mBarAnalyser .HasBearishPressure( cBar, 2 // ); // // Bar Checking Summary ... // // Bullish ... bool isCBarBullishFormed = // ( // hasCBarBullishPattern && isCBarHasBullishPower && isCBarHasBullishPressure // ) // || // ( // isCBarBullishPin || isCBarBreaksUpHH || isCBarBullishEngulfed || isCBarBullishMomentum || isCBarBullishRejected // ) // ; // // Bearish ... bool isCBarBearishFormed = // ( // hasCBarBearishPattern && isCBarHasBearishPower && isCBarHasBearishPressure // ) // || // ( // isCBarBearishPin || isCBarBreaksDownLL || isCBarBearishEngulfed || isCBarBearishMomentum || isCBarBearishRejected // ) // ; // // Now we Have to Detect Higher Peak and Lower Vale // Zones ... // bool hasPeak = conditions.HasPeak(); bool hasVale = conditions.HasVale(); // int higherPeakIDX = -1; int higherPeakStartIDX = -1; datetime higherPeakTime = NULL; double higherPeak = decisionCycleHelper .mX121Helper .xpvHelper .GetHigherPeak( higherPeakIDX, decisionXConditions.peaksBuffer[1] // ); bool hasHigherPeak = higherPeak > 0 && IsValidIndex(higherPeakIDX); if (hasHigherPeak) { // // Detect Higher Peak Start Index ... int idx = higherPeakIDX; bool canContinue = true; while (canContinue) { // double iPeak = decisionCycleHelper .mX121Helper .xpvHelper .GetPeak(idx); canContinue = iPeak == higherPeak; if (!canContinue) { break; } // idx++; } // if (idx > higherPeakIDX) { higherPeakStartIDX = idx - 1; } } // int lowerValeIDX = -1; int lowerValeStartIDX = -1; datetime lowerValeTime = NULL; double lowerVale = decisionCycleHelper .mX121Helper .xpvHelper .GetLowerVale( lowerValeIDX, decisionXConditions.valesBuffer[1] // ); bool hasLowerVale = lowerVale > 0 && IsValidIndex(lowerValeIDX); if (hasLowerVale) { // // Detect Lower Vale Start Index ... int idx = lowerValeIDX; bool canContinue = true; while (canContinue) { // double iVale = decisionCycleHelper .mX121Helper .xpvHelper .GetVale(idx); canContinue = iVale == lowerVale; if (!canContinue) { break; } // idx++; } // if (idx > lowerValeIDX) { lowerValeStartIDX = idx - 1; } } // if (hasHigherPeak) { // XOHCL higherPeakStartBar; bool isInited = higherPeakStartBar.Init( symbol, period, higherPeakStartIDX // ); if (isInited) { higherPeakTime = higherPeakStartBar.time; } } // if (hasLowerVale) { // XOHCL lowerValeStartBar; bool isInited = lowerValeStartBar.Init( symbol, period, lowerValeStartIDX // ); if (isInited) { lowerValeTime = lowerValeStartBar.time; } } // // Detect Pivot ... // double pivotPremiumDiscount = 0; // bool isPivotUpperUpBreaked = false; bool isPivotUpperDownBreaked = false; bool isPivotUpperDownRejected = false; // bool isPivotLowerUpBreaked = false; bool isPivotLowerUpRejected = false; bool isPivotLowerDownBreaked = false; // bool isPriceInPivotPremium = false; bool isPriceInPivotDiscount = false; // bool isPivotPremiumUpBreaked = false; bool isPivotPremiumDownBreaked = false; bool isPivotPremiumUpRejected = false; bool isPivotPremiumDownRejected = false; // bool isPivotDiscountUpBreaked = false; bool isPivotDiscountDownBreaked = false; bool isPivotDiscountUpRejected = false; bool isPivotDiscountDownRejected = false; // bool hasPivot = conditions.pivotZone.IsValid(); // if (!hasPivot) { // bool isSamePeaks = decisionXConditions.peaksBuffer[1] == decisionXConditions.peaksBuffer[2] && decisionXConditions.peaksBuffer[2] == decisionXConditions.peaksBuffer[3]; bool isSameCyclePeaks = decisionXConditions.peaksBuffer[1] == analyseXConditions.peaksBuffer[1] && analyseXConditions.peaksBuffer[1] == verificationXConditions.peaksBuffer[1]; // bool isSameVales = decisionXConditions.valesBuffer[1] == decisionXConditions.valesBuffer[2] && decisionXConditions.valesBuffer[2] == decisionXConditions.valesBuffer[3]; bool isSameCycleVales = decisionXConditions.valesBuffer[1] == analyseXConditions.valesBuffer[1] && analyseXConditions.valesBuffer[1] == verificationXConditions.valesBuffer[1]; // bool isNewPeak = !hasPeak && hasLowerVale && hasHigherPeak && decisionXConditions.isNewPeakUnderLast; if (isNewPeak) { // conditions.pvType = XPV_PEAK; // conditions.peakTime = cTime; conditions.peak = decisionXConditions.peaksBuffer[1]; // conditions.higherPeakTime = higherPeakTime; conditions.higherPeak = higherPeak; // conditions.valeTime = cTime; conditions.vale = decisionXConditions.valesBuffer[1]; // conditions.lowerValeTime = lowerValeTime; conditions.lowerVale = lowerVale; // hasPeak = conditions.HasPeak(); hasVale = conditions.HasVale(); } // bool isNewVale = !hasVale && !isNewPeak && hasLowerVale && hasHigherPeak && decisionXConditions.isNewValeOverLast; if (isNewVale) { // conditions.pvType = XPV_PEAK; // conditions.peakTime = cTime; conditions.peak = decisionXConditions.peaksBuffer[1]; // conditions.higherPeakTime = higherPeakTime; conditions.higherPeak = higherPeak; // conditions.valeTime = cTime; conditions.vale = decisionXConditions.valesBuffer[1]; // conditions.lowerValeTime = lowerValeTime; conditions.lowerVale = lowerVale; // hasPeak = conditions.HasPeak(); hasVale = conditions.HasVale(); } // if (isNewPeak || isNewVale) { // XPVPivot pivot; // pivot.symbol = symbol; pivot.period = period; // pivot.repetition = MathMax( higherPeakIDX, lowerValeIDX // ); pivot.type = conditions.pvType; // pivot.upper = higherPeak; pivot.lower = lowerVale; // bool isHigherPeakOlder = conditions.higherPeakTime < conditions.lowerValeTime; // pivot.to = cTime; pivot.from = isHigherPeakOlder ? conditions.higherPeakTime : conditions.lowerValeTime; // pivot.type = isHigherPeakOlder ? XPV_PEAK : XPV_VALE; // hasPivot = pivot.IsValid(); if (hasPivot) { conditions.pivotZone = pivot; } // } // // Has Pivot ... hasPivot = conditions.pivotZone.IsValid(); } // if (hasPivot) { // // Check Pivot Validation ... // bool isPivotDied = // (cBar.low > conditions.pivotZone.upper && cBar.close > conditions.pivotZone.upper) // || // (cBar.high < conditions.pivotZone.lower && cBar.close < conditions.pivotZone.lower) // ; if (isPivotDied) { conditions.Clean(); } // hasPivot = conditions.pivotZone.IsValid(); if (hasPivot) { // // Detect Pivot States ... // XPOIState analysePivotState; DetectPivotPOIs( conditions.pivotZone, analyseState, analysePivotState // ); // XPOIState decisionPivotState; DetectPivotPOIs( conditions.pivotZone, decisionState, decisionPivotState // ); // // Combine two State ... XPOIState combinedPivotState; XPOIState iStates[]; // AddRef( // analysePivotState, // iStates // // ); AddRef( decisionPivotState, iStates // ); CombineStates( combinedPivotState, iStates // ); combinedPivotState = decisionPivotState; // ArrayFree(iStates); // combinedPivotState.time = decisionPivotState.time; combinedPivotState.symbol = decisionPivotState.symbol; combinedPivotState.period = decisionPivotState.period; // // Hold Only Areas Which on Upper or Lower bondary of Pivot Zone ... FilterPivotState( conditions.pivotZone, combinedPivotState // ); // conditions.pivotZone.state = combinedPivotState; // // Calculate Pivot Ticks Zone ... // int ticksLevels = decisionCycleHelper .mPOIDetector .TicksRangeZoneLevel(); int ticksRange = decisionCycleHelper .mPOIDetector .TicksRangeZoneRange(); // CalculatePivotTickZone( conditions.pivotZone, ticksLevels, ticksRange // ); // // Try to Fill up Pivot Conditions ... // XOHCL pivotCBar; bool isCInited = triggerCycleHelper.GetBar( pivotCBar, cIndex // ); // XOHCL pivotPBar; bool isPInited = triggerCycleHelper.GetBar( pivotPBar, pIndex // ); // double upper = conditions.pivotZone.upper; double lower = conditions.pivotZone.lower; pivotPremiumDiscount = conditions.pivotZone.CalculateMid(); // // Pivot Upper ... // isPivotUpperUpBreaked = isCInited && IsBarBreak( upper, X_DIRECTION_BULLISH, pivotCBar // ); // isPivotUpperDownBreaked = isCInited && IsBarBreak( upper, X_DIRECTION_BEARISH, pivotCBar // ); // isPivotUpperDownRejected = isCInited && IsBarReject( upper, X_DIRECTION_BEARISH, pivotCBar // ); // // Pivot Lower ... // isPivotLowerUpBreaked = isCInited && IsBarBreak( lower, X_DIRECTION_BULLISH, pivotCBar // ); // isPivotLowerUpRejected = isCInited && IsBarReject( lower, X_DIRECTION_BULLISH, pivotCBar // ); // isPivotLowerDownBreaked = isCInited && IsBarBreak( lower, X_DIRECTION_BEARISH, pivotCBar // ); // // Pivot Premium / Discount ... // bool isPriceInPivotPremium = isCInited && ask < upper && bid < upper && ask > pivotPremiumDiscount && bid > pivotPremiumDiscount; // bool isPriceInPivotDiscount = isCInited && ask > lower && bid > lower && ask < pivotPremiumDiscount && bid < pivotPremiumDiscount; // // // // isPivotPremiumUpBreaked = isCInited && isPInited && IsBarBreak( pivotPremiumDiscount, X_DIRECTION_BULLISH, pivotCBar // ) && pivotPBar.high > pivotPremiumDiscount; // isPivotPremiumDownBreaked = isCInited && isPInited && IsBarBreak( pivotPremiumDiscount, X_DIRECTION_BEARISH, pivotCBar // ) && pivotPBar.high > pivotPremiumDiscount; // isPivotPremiumUpRejected = isCInited && isPInited && IsBarReject( pivotPremiumDiscount, X_DIRECTION_BULLISH, pivotCBar // ) && pivotPBar.high > pivotPremiumDiscount; // isPivotPremiumDownRejected = isCInited && isPInited && IsBarReject( pivotPremiumDiscount, X_DIRECTION_BEARISH, pivotCBar // ) && pivotPBar.high > pivotPremiumDiscount; // // // // isPivotDiscountUpBreaked = isCInited && isPInited && IsBarBreak( pivotPremiumDiscount, X_DIRECTION_BULLISH, pivotCBar // ) && pivotPBar.low < pivotPremiumDiscount; // isPivotDiscountDownBreaked = isCInited && isPInited && IsBarBreak( pivotPremiumDiscount, X_DIRECTION_BEARISH, pivotCBar // ) && pivotPBar.low < pivotPremiumDiscount; // isPivotDiscountUpRejected = isCInited && isPInited && IsBarReject( pivotPremiumDiscount, X_DIRECTION_BULLISH, pivotCBar // ) && pivotPBar.low < pivotPremiumDiscount; // isPivotDiscountDownRejected = isCInited && isPInited && IsBarReject( pivotPremiumDiscount, X_DIRECTION_BEARISH, pivotCBar // ) && pivotPBar.low < pivotPremiumDiscount; // // Detect Bar Patterns ... // if (isCBarBullishRejected) { // int count = conditions.pivotZone.state.CountBullishRejectionBars(); isCBarBullishRejected = IsValidSize(count); if (isCBarBullishRejected) { // bool hasBar = false; for (int i = 0; i < count; i++) { // XCRejectionBar *iBar = conditions.pivotZone.state.bullishRejectionBars[i]; // hasBar = iBar.BarTime() == cBar.time; if (hasBar) { break; } } // isCBarBullishRejected = hasBar; } } // if (isCBarBearishRejected) { // int count = conditions.pivotZone.state.CountBearishRejectionBars(); isCBarBearishRejected = IsValidSize(count); if (isCBarBearishRejected) { // bool hasBar = false; for (int i = 0; i < count; i++) { // XCRejectionBar *iBar = conditions.pivotZone.state.bearishRejectionBars[i]; // hasBar = iBar.BarTime() == cBar.time; if (hasBar) { break; } } // isCBarBearishRejected = hasBar; } } // // Draw Pivot ... // XCBaseObject *drawnObjects[]; // triggerCycleHelper.mPOIDetector.mDrawer.DrawPivot( // conditions.pivotZone, // drawnObjects, // true, // Draw State ... // false, // State As Box ... // true // Tick Zone ... // ); } } // // // // // Summarize Conditions ... // bool isCondition1Bullish = // hasPivot && // // XSTR ... decisionXConditions.isStrBullish && // // XCHE ... (consolidationXConditions.isCheBullish && consolidationXConditions.isClosedOverCheMin && cBar.low > consolidationXConditions.cheMax) && // // XPV ... (isCBarBullishRejected && pBar.open > cBar.close && decisionXConditions.isNewValeUnderLast && decisionXConditions.valesBuffer[1] > conditions.pivotZone.lower) && // true // ; // bool isCondition1Bearish = // hasPivot && // // XSTR ... decisionXConditions.isStrBearish && // // XCHE ... (consolidationXConditions.isCheBearish && consolidationXConditions.isClosedUnderCheMin && cBar.high < consolidationXConditions.cheMin) && // // XPV ... (isCBarBearishRejected && pBar.open < cBar.close && decisionXConditions.isNewPeakOverLast && decisionXConditions.peaksBuffer[1] < conditions.pivotZone.upper) && // true // ; // bool hasCondition1 = isCondition1Bullish || isCondition1Bearish; if (hasCondition1) { // ENUM_X_DIRECTION pzDir = isCondition1Bullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // double point = GetEntry( conditions.symbol, pzDir // ); // // Manipulate Conditions Point ... // conditions.point = pivotPremiumDiscount; // // Manipulate Conditions Pivot ... // conditions.pivot = isCondition1Bullish ? conditions.pivotZone.upper : conditions.pivotZone.lower; // // conditions.Clean(); // isCondition1Bullish = false; // isCondition1Bearish = false; } // // // // isBullish = // isCondition1Bullish // ; // isBearish = // isCondition1Bearish // ; // result = isBullish || isBearish; if (!result) { // // Cleanup Arrays ... ArrayFree(triggerPoiEvents); ArrayFree(triggerCycleEvents); ArrayFree(decisionPoiEvents); ArrayFree(decisionCycleEvents); ArrayFree(analysePoiEvents); ArrayFree(analyseCycleEvents); ArrayFree(verificationPoiEvents); ArrayFree(verificationCycleEvents); ArrayFree(consolidationPoiEvents); ArrayFree(consolidationCycleEvents); ArrayFree(visionPoiEvents); ArrayFree(visionCycleEvents); // return result; } // conditions.setupTime = cTime; conditions.dir = isBullish ? X_DIRECTION_BULLISH : X_DIRECTION_BEARISH; // // Cleanup Arrays ... ArrayFree(triggerPoiEvents); ArrayFree(triggerCycleEvents); ArrayFree(decisionPoiEvents); ArrayFree(decisionCycleEvents); ArrayFree(analysePoiEvents); ArrayFree(analyseCycleEvents); ArrayFree(verificationPoiEvents); ArrayFree(verificationCycleEvents); ArrayFree(consolidationPoiEvents); ArrayFree(consolidationCycleEvents); ArrayFree(visionPoiEvents); ArrayFree(visionCycleEvents); // return result; } // // Detect Trigger Conditions ... bool DetectX121SMCXPVTSiganlTrigger( // X121SMCStrategyXPVTSignalConditions &conditions, // string _symbol, ENUM_TIMEFRAMES _period, // XC121SMCCycleHelper *triggerCycleHelper, XC121SMCCycleHelper *decisionCycleHelper, XC121SMCCycleHelper *analyseCycleHelper, XC121SMCCycleHelper *verificationCycleHelper, XC121SMCCycleHelper *consolidationCycleHelper, XC121SMCCycleHelper *visionCycleHelper, // int maxAllowedSetupAge = 60 // // ) { // bool result = false; // result = conditions.IsSetuped(); if (!result) { return result; } // datetime setupTime = conditions.setupTime; ENUM_X_DIRECTION setupDir = conditions.dir; // bool isBullish = IsBullish(setupDir); bool isBearish = IsBearish(setupDir); // int zIndex = 0; int cIndex = zIndex + 1; int pIndex = cIndex + 1; int ppIndex = pIndex + 1; // int loopback = 10; // string symbol = _symbol; ENUM_TIMEFRAMES period = _period; // XOHCL zBar; result = zBar.Init( symbol, period, zIndex // ); if (!result) { return result; } // XOHCL cBar; result = cBar.Init( symbol, period, cIndex // ); if (!result) { return result; } // XOHCL pBar; result = pBar.Init( symbol, period, pIndex // ); if (!result) { return result; } // double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); double points = GetPoints(symbol); // int swingLoopback = 9; double ll = cBar.FindLowest(swingLoopback, MODE_LOW); double hh = cBar.FindHighest(swingLoopback, MODE_HIGH); double llDown = cBar.FindLowesttDown(swingLoopback); double hhUp = cBar.FindHighestUp(swingLoopback); // // Cycles Conditions ... // // Trigger ... ENUM_XPOI_EVENTS triggerPoiEvents[]; ENUM_X_CYCLE_EVENTS triggerCycleEvents[]; X121SMCCycleConditions triggerConditions; result = triggerCycleHelper.GetConditions( triggerCycleEvents, triggerPoiEvents, triggerConditions, zIndex, loopback // ); if (!result) { return result; } // // Decision ... ENUM_XPOI_EVENTS decisionPoiEvents[]; ENUM_X_CYCLE_EVENTS decisionCycleEvents[]; X121SMCCycleConditions decisionConditions; result = decisionCycleHelper.GetConditions( decisionCycleEvents, decisionPoiEvents, decisionConditions, zIndex, loopback // ); if (!result) { return result; } // // Analyse ... ENUM_XPOI_EVENTS analysePoiEvents[]; ENUM_X_CYCLE_EVENTS analyseCycleEvents[]; X121SMCCycleConditions analyseConditions; result = analyseCycleHelper.GetConditions( analyseCycleEvents, analysePoiEvents, analyseConditions, zIndex, loopback // ); if (!result) { return result; } // // Verification ... ENUM_XPOI_EVENTS verificationPoiEvents[]; ENUM_X_CYCLE_EVENTS verificationCycleEvents[]; X121SMCCycleConditions verificationConditions; result = verificationCycleHelper.GetConditions( verificationCycleEvents, verificationPoiEvents, verificationConditions, zIndex, loopback // ); if (!result) { return result; } // // Consolidation ... ENUM_XPOI_EVENTS consolidationPoiEvents[]; ENUM_X_CYCLE_EVENTS consolidationCycleEvents[]; X121SMCCycleConditions consolidationConditions; result = consolidationCycleHelper.GetConditions( consolidationCycleEvents, consolidationPoiEvents, consolidationConditions, zIndex, loopback // ); if (!result) { return result; } // // Vision ... ENUM_XPOI_EVENTS visionPoiEvents[]; ENUM_X_CYCLE_EVENTS visionCycleEvents[]; X121SMCCycleConditions visionConditions; result = visionCycleHelper.GetConditions( visionCycleEvents, visionPoiEvents, visionConditions, zIndex, loopback // ); if (!result) { return result; } // // Cycles POI States ... XPOIState triggerState = triggerConditions.state; XPOIState decisionState = decisionConditions.state; XPOIState analyseState = analyseConditions.state; XPOIState verificationState = verificationConditions.state; XPOIState consolidationState = consolidationConditions.state; XPOIState visionState = visionConditions.state; // // Cycle X121Conditions ... X121Conditions triggerXConditions = triggerConditions.x121Conditions; X121Conditions decisionXConditions = decisionConditions.x121Conditions; X121Conditions analyseXConditions = analyseConditions.x121Conditions; X121Conditions verificationXConditions = verificationConditions.x121Conditions; X121Conditions consolidationXConditions = consolidationConditions.x121Conditions; X121Conditions visionXConditions = visionConditions.x121Conditions; // // Trigger Conditions ... // // SAR ... double sar = decisionXConditions.sarBuffer[1]; // // STR ... double str = decisionXConditions.strBuffer[1]; // // CHE ... double le1 = decisionXConditions.le1Buffer[1]; double le2 = decisionXConditions.le2Buffer[1]; double se1 = decisionXConditions.se1Buffer[1]; double se2 = decisionXConditions.se2Buffer[1]; // // ATR ... double atrUpper = decisionXConditions.atrUpperBuffer[1]; double atrLower = decisionXConditions.atrLowerBuffer[1]; // // PV ... double peak = decisionXConditions.peaksBuffer[1]; double vale = decisionXConditions.valesBuffer[1]; // int higherPeakIDX = -1; double higherPeak = decisionCycleHelper .mX121Helper .xpvHelper.GetHigherPeak( higherPeakIDX, peak // ); // int lowerValeIDX = -1; double lowerVale = decisionCycleHelper .mX121Helper .xpvHelper.GetLowerVale( lowerValeIDX, vale // ); // // Slopes ... // bool isRsiSlopeBullish = decisionXConditions.isRsiSlopeBullish; bool isStrSlopeBullish = decisionXConditions.isStrSlopeBullish; bool isAtrUpperSlopeBullish = decisionXConditions.isAtrUpperSlopeBullish; bool isAtrLowerSlopeBullish = decisionXConditions.isAtrLowerSlopeBullish; bool isVwapFastSlopeBullish = decisionXConditions.isVwapFastSlopeBullish; bool isVwapMidSlopeBullish = decisionXConditions.isVwapMidSlopeBullish; bool isVwapSlowSlopeBullish = decisionXConditions.isVwapSlowSlopeBullish; // bool isRsiSlopeBearish = decisionXConditions.isRsiSlopeBearish; bool isStrSlopeBearish = decisionXConditions.isStrSlopeBearish; bool isAtrUpperSlopeBearish = decisionXConditions.isAtrUpperSlopeBearish; bool isAtrLowerSlopeBearish = decisionXConditions.isAtrLowerSlopeBearish; bool isVwapFastSlopeBearish = decisionXConditions.isVwapFastSlopeBearish; bool isVwapMidSlopeBearish = decisionXConditions.isVwapMidSlopeBearish; bool isVwapSlowSlopeBearish = decisionXConditions.isVwapSlowSlopeBearish; // bool isSlopesBullish = isRsiSlopeBullish && isStrSlopeBullish && isAtrUpperSlopeBullish && isAtrLowerSlopeBullish && isVwapFastSlopeBullish && isVwapMidSlopeBullish && isVwapSlowSlopeBullish; // bool isSlopesBearish = isRsiSlopeBearish && isStrSlopeBearish && isAtrUpperSlopeBearish && isAtrLowerSlopeBearish && isVwapFastSlopeBearish && isVwapMidSlopeBearish && isVwapSlowSlopeBearish; // double point = conditions.point; // bool isPointBreaked = // isBullish // ? ask > point && bid > point // : ask < point && bid < point; bool isPointBreaked = IsBarBreak( point, setupDir, cBar // ); // // Summary ... // isBullish = // isBullish && // isPointBreaked && // isSlopesBullish && cBar.IsBullish() // ; // isBearish = // isBearish && // isPointBreaked && // isSlopesBearish && cBar.IsBearish() // ; // result = isBullish || isBearish; if (!result) { // // Cleanup Setup Conditions ... int setupAge = conditions.GetSetupAge(); if (IsValidSize(setupAge) && IsValidSize(maxAllowedSetupAge) && setupAge >= maxAllowedSetupAge) { conditions.Clean(); } // // Cleanup Arrays ... ArrayFree(triggerPoiEvents); ArrayFree(triggerCycleEvents); ArrayFree(decisionPoiEvents); ArrayFree(decisionCycleEvents); ArrayFree(analysePoiEvents); ArrayFree(analyseCycleEvents); ArrayFree(verificationPoiEvents); ArrayFree(verificationCycleEvents); ArrayFree(consolidationPoiEvents); ArrayFree(consolidationCycleEvents); ArrayFree(visionPoiEvents); ArrayFree(visionCycleEvents); // return result; } // // Detect Nearest Pivot Point ... // // Detect Target ... double target = CalculateTarget( cBar, decisionState, setupDir // ); if (target == 0) { // target = CalculateTarget( cBar, analyseState, setupDir // ); // if (target == 0) { // target = CalculateTarget( cBar, verificationState, setupDir // ); } } target = 0; // double entry = GetEntry( conditions.symbol, setupDir // ); // // Filling SL Candidates ... double momentumBarPointsDif = 30 * points; // // Bullish Momentum Bar Selection ... XOHCL bullishMomentumBar; int bullishMomentumBarsCount = decisionState.CountBullishMomentumBars(); if (IsValidSize(bullishMomentumBarsCount)) { // for (int i = 0; i < bullishMomentumBarsCount; i++) { // XCMomentumBar *iMomentum = decisionState.bullishMomentumBars[i]; // XOHCL iBar; bool isFilled = iMomentum.FillBar(iBar); if (!isFilled) { continue; } // bool isValidDistane = (MathAbs(iBar.low) - entry) >= momentumBarPointsDif; if (!isValidDistane) { continue; } // bool isIndexPassed = iBar.Index() <= 5; if (!isIndexPassed) { continue; } // bool canSet = !bullishMomentumBar.IsValid() || (bullishMomentumBar.IsValid() && bullishMomentumBar.low < entry && bullishMomentumBar.Index() > iBar.Index()); if (canSet) { bullishMomentumBar = iBar; } } } // // Bearish Momentum Bar Selection ... XOHCL bearishMomentumBar; int bearishMomentumBarsCount = decisionState.CountBearishMomentumBars(); if (IsValidSize(bearishMomentumBarsCount)) { // for (int i = 0; i < bearishMomentumBarsCount; i++) { // XCMomentumBar *iMomentum = decisionState.bearishMomentumBars[i]; // XOHCL iBar; bool isFilled = iMomentum.FillBar(iBar); if (!isFilled) { continue; } // bool isValidDistane = (MathAbs(iBar.high) - entry) >= momentumBarPointsDif; if (!isValidDistane) { continue; } // bool isIndexPassed = iBar.Index() <= 5; if (!isIndexPassed) { continue; } // bool canSet = !bearishMomentumBar.IsValid() || (bearishMomentumBar.IsValid() && bearishMomentumBar.high > entry && bearishMomentumBar.Index() > iBar.Index()); if (canSet) { bearishMomentumBar = iBar; } } } // double sls[]; Add( sar, sls // ); Add( str, sls // ); // if (isBullish) { // Add( atrLower, sls // ); // // // Add( // vale, // sls // // ); // if (bullishMomentumBar.IsValid()) { // Add( bullishMomentumBar.low, sls // ); } // // // if (IsValidIndex(lowerValeIDX)) // { // // // Add( // lowerVale, // sls // // ); // } // if (le1 != EMPTY_VALUE) { // Add( le1, sls // ); } // if (le2 != EMPTY_VALUE) { // Add( le2, sls // ); } } else { // Add( atrUpper, sls // ); // // // Add( // peak, // sls // // ); // if (bearishMomentumBar.IsValid()) { // Add( bearishMomentumBar.high, sls // ); } // // if (IsValidIndex(higherPeakIDX)) // { // // // Add( // higherPeak, // sls // // ); // } // if (se1 != EMPTY_VALUE) { // Add( se1, sls // ); } // if (se2 != EMPTY_VALUE) { // Add( se2, sls // ); } } // double iAtr = decisionConditions.x121Conditions.atrBuffer[1]; iAtr *= 1.5; // double slsMin = GetMin(sls); double slsMax = GetMax(sls); // double sl = isBullish ? slsMin - iAtr : slsMax + iAtr; double risk = MathAbs(entry - sl); double riskInPoints = risk / points; if (riskInPoints >= 150) { // target = isBullish ? entry + (points * 200) : entry - (points * 200); // target = 0; } // // Filling Conditions Props ... conditions.sl = sl; conditions.target = target; conditions.triggerTime = cTime; conditions.type = isBullish ? X_POSITION_TYPE_LONG : X_POSITION_TYPE_SHORT; // // Cleanup Arrays ... ArrayFree(triggerPoiEvents); ArrayFree(triggerCycleEvents); ArrayFree(decisionPoiEvents); ArrayFree(decisionCycleEvents); ArrayFree(analysePoiEvents); ArrayFree(analyseCycleEvents); ArrayFree(verificationPoiEvents); ArrayFree(verificationCycleEvents); ArrayFree(consolidationPoiEvents); ArrayFree(consolidationCycleEvents); ArrayFree(visionPoiEvents); ArrayFree(visionCycleEvents); // return result; } // bool DetectX121SMCXPVTGuards( X121SMCGuard &guards[], const XPosition &positions[], XC121SMCCycleHelper *triggerCycleHelper, XC121SMCCycleHelper *decisionCycleHelper, XC121SMCCycleHelper *analyseCycleHelper, XC121SMCCycleHelper *verificationCycleHelper, XC121SMCCycleHelper *consolidationCycleHelper, XC121SMCCycleHelper *visionCycleHelper // ) { // bool result = false; // string provider = ToString(X_121_SMC_PROVIDER_X); // // result = DetectX121SMCGuards( // provider, // guards, // positions, // triggerCycleHelper, // decisionCycleHelper, // analyseCycleHelper, // verificationCycleHelper, // consolidationCycleHelper, // visionCycleHelper // // ); // return result; } // int AddX121SMCXPVTConditionsIfNotExists( X121SMCStrategyXPVTSignalConditions &item, X121SMCStrategyXPVTSignalConditions &items[], int maxAllowed = 10 // ) { // int result = 0; // bool isSetuped = IsValid(item.setupTime) && HasDirection(item.dir); if (!isSetuped) { return result; } // int count = ArraySize(items); if (IsValidSize(count)) { // // Copy Original Items ... X121SMCStrategyXPVTSignalConditions tmpItems[]; Copy( items, tmpItems // ); // // Prese Item Data ... bool isBullish = IsBullish(item.dir); // for (int i = 0; i < count; i++) { // X121SMCStrategyXPVTSignalConditions iItem = tmpItems[i]; // bool canRemove = item.dir == iItem.dir && item.pivot == iItem.pivot; if (canRemove) { // ArrayRemove( items, i, 1 // ); } } // Clean(tmpItems); } // AddRef( item, items // ); // // Remove Olds ... CleanupArray( items, maxAllowed // ); // result = ArraySize(items); // return result; } // int DrawX121SMCXPVTConditions( X121SMCStrategyXPVTSignalConditions &conditions, XCBaseObject *&drawnObjects[], XCPOIDrawer *drawer // ) { // int result = 0; // Clean(drawnObjects); // if (drawer == NULL) { return result; } // bool isSetuped = conditions.IsSetuped(); if (!isSetuped) { return result; } // bool hasPivot = conditions.pivotZone.IsValid(); if (hasPivot) { // XCBaseObject *pivotObjects[]; drawer.DrawPivot( conditions.pivotZone, pivotObjects, true, // State ... false, // State as Box ... false // Ticks Zone ... ); // Copy( pivotObjects, drawnObjects, false // ); } // return result; } //