From e45fee2729163dc7ed2aaa63b8fa8b81291fa1d2 Mon Sep 17 00:00:00 2001 From: Hadi Khazaee Asl Date: Mon, 16 Dec 2024 08:29:07 +0330 Subject: [PATCH] last ... --- Classes/x-saherelm.x-cobject.class.mq5 | 134 + Documents/BKP/tmp.x121.smc.mq5 | 5368 +++++++++++++++++ Libraries/x-saherelm.common.lib.mq5 | 46 +- Libraries/x-saherelm.x-poi.lib.mq5 | 130 +- MQL5.code-workspace | 3 +- .../x-121.smc.market.cycle.helper.class.mq5 | 187 +- X121SMCEA/Libraries/x-121.smc.lib.mq5 | 175 +- .../x-121.smc.test.strategy.class.mq5 | 2645 +------- 8 files changed, 6153 insertions(+), 2535 deletions(-) diff --git a/Classes/x-saherelm.x-cobject.class.mq5 b/Classes/x-saherelm.x-cobject.class.mq5 index 0076b403..26fc987e 100644 --- a/Classes/x-saherelm.x-cobject.class.mq5 +++ b/Classes/x-saherelm.x-cobject.class.mq5 @@ -63,6 +63,7 @@ enum ENUM_XCHARTOBJECTS X_BEARISH_FVG_OBJ = 9875, X_TICK_ZONE_OBJ = 9876, X_TICKS_ZONE_OBJ = 9877, + X_CONSOLIDATION_ZONE_OBJ = 9878, }; enum ENUM_X_CHART_IDS @@ -1469,6 +1470,139 @@ class XCBullishFairValueGapObject : public XCZoneObject } }; +class XCConsolidationZoneObject : public XCBaseObject +{ + // + public: + // + + /** + * Creator ... + * + * @param chart_id: Long, Specified Chart ID ... + * @param window: Integer, Specified Chart Window ID ... + * @param zone: XConsolidationZone instance ... + * @param prefix: String ... + * + * @return ( bool ) + */ + bool Create( + long chart_id, + int window, + XConsolidationZone &zone, + string prefix = NULL // + ) + { + // + bool result = false; + + // + result = zone.IsValid(); + if (!result) + { + return result; + } + + // + string name = zone.GetTag(); + if (IsValid(prefix)) + { + name = prefix + "_" + name; + } + + // + result = mRect.Create( + chart_id, + name, + window, + zone.From(), + zone.upper, + TimeCurrent(), + zone.lower // + ); + + // + if (result) + { + ObjName(name); + } + + + // + return result; + } + + // + // Virtual ... + + /** + * Retrieve Object Type ... + * + * @return ( ENUM_XCHARTOBJECTS ) + */ + virtual ENUM_XCHARTOBJECTS Type() + { + return X_CONSOLIDATION_ZONE_OBJ; + } + + // + // Setter(s) ... + + /** + * Set Zone Width ... + * + * @param value: Integer ... + */ + void ZoneWidth(int value) + { + // + if (value < 1) + { + value = 1; + } + + // + mRect.Width(value); + } + + /** + * Set Zone Color ... + * + * @param value: Color ... + */ + void ZoneColor(color value) + { + mRect.Color(value); + } + + /** + * Set Zone Style ... + * + * @param value: ENUM_LINE_STYLE member ... + */ + void ZoneStyle(ENUM_LINE_STYLE value) + { + mRect.Style(value); + } + + /** + * Set Zone Fill ... + * + * @param value: Boolean ... + */ + void ZoneFill(bool value) + { + mRect.Fill(value); + } + + // + private: + // + CChartObjectRectangle mRect; + + // +}; + // // Bearish Fair Value Gaps ... class XCBearishFairValueGapObject : public XCZoneObject diff --git a/Documents/BKP/tmp.x121.smc.mq5 b/Documents/BKP/tmp.x121.smc.mq5 index ab72212b..5039825d 100644 --- a/Documents/BKP/tmp.x121.smc.mq5 +++ b/Documents/BKP/tmp.x121.smc.mq5 @@ -3358,3 +3358,5371 @@ bool DetectValisSupplyZone( /////////////////////////////////////////////////////////////////////////////////////////// + + // + // TODO: Remove this ... + XTestProiderConditions mTestConditions; + bool DetectTestSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + bool isBullish = false; + bool isBearish = false; + + // + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double selectedSL = 0; + + // + // Retrieve Peak and Vale ... + double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + + // + X121SMCCycleConditions triggerConditions = conditions.triggerConditions; + X121SMCCycleConditions decisionConditions = conditions.decisionConditions; + X121SMCCycleConditions analyseConditions = conditions.analyseConditions; + X121SMCCycleConditions verificationConditions = conditions.verificationConditions; + X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions; + X121SMCCycleConditions visionConditions = conditions.visionConditions; + + // + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + int zoneValidationDivider = 10; + + // + // Try to Detect Setup Conditions ... + ENUM_X_DIRECTION setupDir; + result = mTestConditions.IsSetuped(setupDir); + if (!result) + { + // + // First we must check a new Peak or Vale Happens ... + bool isNewPeak = conditions.triggerConditions.x121Conditions.isNewPeak; + bool isNewVale = conditions.triggerConditions.x121Conditions.isNewVale; + + // + result = isNewPeak || + isNewVale; + if (!result) + { + return result; + } + + // + mTestConditions.isNewPeak = isNewPeak; + mTestConditions.isNewVale = isNewVale; + + // + // We have to Check the Peaks and Vales Happens inside a Demand or Supply Zone ... + // in Vision State ... + + // + bool hasVisionSupplyZone = false; + XCSupplyZone *visionSupplyZone = NULL; + int visionSupplyZonesCount = visionState.CountSupplyZones(); + if (isNewPeak && + IsValidSize(visionSupplyZonesCount)) + { + // + // Try to Find Inside Zone ... + for (int i = 0; i < visionSupplyZonesCount; i++) + { + // + XCSupplyZone *iZone = visionState.supplyZones[i]; + double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; + + // + hasVisionSupplyZone = + // + peak >= iZone.Lower() && + peak <= iZone.Upper() && + peak > iZone.Upper() - zoneValidRange + // + ; + if (hasVisionSupplyZone) + { + // + visionSupplyZone = iZone; + break; + } + } + } + + // + bool hasVisionDemandZone = false; + XCDemandZone *visionDemandZone = NULL; + int visionDemandZonesCount = visionState.CountDemandZones(); + if (isNewVale && + IsValidSize(visionDemandZonesCount)) + { + // + // Try to Find Inside Zone ... + for (int i = 0; i < visionDemandZonesCount; i++) + { + // + XCDemandZone *iZone = visionState.demandZones[i]; + double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; + + // + hasVisionDemandZone = + // + vale >= iZone.Lower() && + vale <= iZone.Upper() && + vale < iZone.Lower() + zoneValidRange + // + ; + if (hasVisionDemandZone) + { + // + visionDemandZone = iZone; + break; + } + } + } + + // + result = hasVisionSupplyZone || + hasVisionDemandZone; + if (!result) + { + return result; + } + + // + mTestConditions.visionSupplyZone = visionSupplyZone; + mTestConditions.visionDemandZone = visionDemandZone; + + // + mTestConditions.hasVisionSupplyZone = hasVisionSupplyZone; + mTestConditions.hasVisionDemandZone = hasVisionDemandZone; + + // + double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double decisionPeak = conditions.decisionConditions.x121Conditions.peaksBuffer[0]; + double analysePeak = conditions.analyseConditions.x121Conditions.peaksBuffer[0]; + double verificationPeak = conditions.verificationConditions.x121Conditions.peaksBuffer[0]; + double consolidationPeak = conditions.consolidationConditions.x121Conditions.peaksBuffer[0]; + double visionPeak = conditions.visionConditions.x121Conditions.peaksBuffer[0]; + + // + bool isPeaksSame = + // + triggerPeak && + decisionPeak && + analysePeak && + verificationPeak && + consolidationPeak && + visionPeak + // + ; + + // + double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + double decisionVale = conditions.decisionConditions.x121Conditions.valesBuffer[0]; + double analyseVale = conditions.analyseConditions.x121Conditions.valesBuffer[0]; + double verificationVale = conditions.verificationConditions.x121Conditions.valesBuffer[0]; + double consolidationVale = conditions.consolidationConditions.x121Conditions.valesBuffer[0]; + double visionVale = conditions.visionConditions.x121Conditions.valesBuffer[0]; + + // + bool isValesSame = + // + triggerVale && + decisionVale && + analyseVale && + verificationVale && + consolidationVale && + visionVale + // + ; + + // + mTestConditions.hasSamePeaks = isPeaksSame; + mTestConditions.hasSameVales = isValesSame; + + // + isBullish = + // + isNewVale && + isPeaksSame && + isValesSame && + hasVisionDemandZone + // + ; + + // + isBearish = + // + isNewPeak && + isPeaksSame && + isValesSame && + hasVisionSupplyZone + // + ; + + // + result = + isBullish || + isBearish; + if (!result) + { + return result; + } + + // + mTestConditions.setupTime = TimeCurrent(); + + // + result = mTestConditions.IsSetuped(setupDir); + if (!result) + { + return result; + } + + // + // Alert ... + string message = providerStr + " Conditions Set Upped: " + ToString(setupDir); + Alert(message); + } + else + { + // + // Try to Detect Trigger Conditions ... + mTestConditions.symbol = symbol; + mTestConditions.period = period; + + // + // Try to Find Support Zone which Vales Inside it ... + bool hasConsolidationSupportZone = false; + XCSupportZone *consolidationSupportZone = NULL; + int consolidationSupportZonesCount = consolidationState.CountSupportZones(); + if (IsValidSize(consolidationSupportZonesCount)) + { + // + for (int i = 0; i < consolidationSupportZonesCount; i++) + { + // + XCSupportZone *iZone = consolidationState.supportZones[i]; + // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; + + // + hasConsolidationSupportZone = + // + peak >= iZone.Lower() && + peak <= iZone.Upper() + // && + // vale < iZone.Upper() - zoneValidRange + // + ; + if (hasConsolidationSupportZone) + { + // + consolidationSupportZone = iZone; + break; + } + } + } + + // + // Try to Find Resistance Zone which Peaks Inside it ... + bool hasConsolidationResistanceZone = false; + XCResistanceZone *consolidationResistanceZone = NULL; + int consolidationResistanceZonesCount = consolidationState.CountResistanceZones(); + if (IsValidSize(consolidationResistanceZonesCount)) + { + // + for (int i = 0; i < consolidationResistanceZonesCount; i++) + { + // + XCResistanceZone *iZone = consolidationState.resistanceZones[i]; + // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; + + // + hasConsolidationResistanceZone = + // + vale >= iZone.Lower() && + vale <= iZone.Upper() + // && + // peak > iZone.Lower() + zoneValidRange + // + ; + if (hasConsolidationResistanceZone) + { + // + consolidationResistanceZone = iZone; + break; + } + } + } + + // + result = hasConsolidationSupportZone || + hasConsolidationResistanceZone; + if (!result) + { + return result; + } + + // + result = + // + (IsBullish(setupDir) && + hasConsolidationResistanceZone) + // + || + // + (IsBearish(setupDir) && + hasConsolidationSupportZone) + // + ; + if (!result) + { + return result; + } + + // + // Detect State Conditions ... + + // + // Vision ... + + // + bool isVisionBullishPassed = + // + // Sar ... + visionConditions.x121Conditions.isSarBullish + // + && + // + // VWap ... + visionConditions.x121Conditions.isVWapFastBullish + // + ; + + // + bool isVisionBearishPassed = + // + // Sar ... + visionConditions.x121Conditions.isSarBearish + // + && + // + // VWap ... + visionConditions.x121Conditions.isVWapFastBearish + // + ; + + // + bool isVisionPassed = isVisionBullishPassed || + isVisionBearishPassed; + result = isVisionPassed; + if (!result) + { + return result; + } + + // + // Consolidation ... + + // + bool isConsolidationBullishPassed = + // + // Sar ... + consolidationConditions.x121Conditions.isSarBullish + // + && + // + // VWap State ... + consolidationConditions.x121Conditions.isVWapBullishState + // + && + // + // VWap Order ... + consolidationConditions.x121Conditions.isVWapBullishOrdered + // + ; + + // + bool isConsolidationBearishPassed = + // + // + // Sar ... + consolidationConditions.x121Conditions.isSarBearish + // + && + // + // VWap State ... + consolidationConditions.x121Conditions.isVWapBearishState + // + && + // + // VWap Order ... + consolidationConditions.x121Conditions.isVWapBearishOrdered + // + ; + + // + bool isConsolidationPassed = isConsolidationBullishPassed || + isConsolidationBearishPassed; + result = isConsolidationPassed; + if (!result) + { + return result; + } + + // + // Verification ... + + // + bool isVerificationBullishPassed = + // + // Sar ... + verificationConditions.x121Conditions.isSarBullish + // + && + // + // VWap State ... + verificationConditions.x121Conditions.isVWapBullishState + // + && + // + // VWap Order ... + verificationConditions.x121Conditions.isVWapBullishOrdered + // + ; + + // + bool isVerificationBearishPassed = + // + // Sar ... + verificationConditions.x121Conditions.isSarBearish + // + && + // + // VWap State ... + verificationConditions.x121Conditions.isVWapBearishState + // + && + // + // VWap Order ... + verificationConditions.x121Conditions.isVWapBearishOrdered + // + ; + + // + bool isVerificationPassed = isVerificationBullishPassed || + isVerificationBearishPassed; + result = isVerificationPassed; + if (!result) + { + return result; + } + + // + // Analyse ... + + // + bool isAnalyseBullishPassed = + // + // Sar ... + analyseConditions.x121Conditions.isSarBullish + // + && + // + // VWap Order ... + analyseConditions.x121Conditions.isVWapBullishOrdered + // + && + // + // VWap State ... + (analyseConditions.x121Conditions.isVWapBullishState || + (analyseConditions.x121Conditions.isVWapMidBullish && + analyseConditions.x121Conditions.isVWapSlowBullish)) + // + ; + + // + bool isAnalyseBearishPassed = + // + // Sar ... + analyseConditions.x121Conditions.isSarBearish + // + && + // + // VWap Order ... + analyseConditions.x121Conditions.isVWapBearishOrdered + // + && + // + // VWap State ... + (analyseConditions.x121Conditions.isVWapBearishState || + (analyseConditions.x121Conditions.isVWapMidBearish && + analyseConditions.x121Conditions.isVWapSlowBearish)) + // + ; + + // + bool isAnalysePassed = isAnalyseBullishPassed || + isAnalyseBearishPassed; + result = isAnalysePassed; + if (!result) + { + return result; + } + + // + // Decision ... + + // + double decisionPeak = decisionConditions.x121Conditions.peaksBuffer[1]; + double decisionVale = decisionConditions.x121Conditions.valesBuffer[1]; + + // + XOHCL decisionCBar; + result = mDecisionCycleHelper.GetBar( + decisionCBar, + cIndex // + ); + + // + // Check Fibo Pressure ... + ENUM_X_DIRECTION pressureDir; + bool hasPressurePin = mBarAnalyser.HasFiboPressure( + decisionCBar, + pressureDir // + ); + + // + bool isBarBullish = + // + (hasPressurePin && + IsBullish(pressureDir)) + // + && + // + decisionCBar.low == decisionVale + // + ; + + // + bool isBarBearish = + // + (hasPressurePin && + IsBearish(pressureDir)) + // + && + // + decisionCBar.high == decisionPeak + // + ; + + // + bool isBarPassed = isBarBullish || + isBarBearish; + result = isBarPassed; + if (!result) + { + return result; + } + + // + bool isDecisionBullishPassed = + // + // Bar ... + isBarBullish + // + && + // + // VWap Order ... + decisionConditions.x121Conditions.isVWapBullishOrdered + // + ; + + // + bool isDecisionBearishPassed = + // + // Bar ... + isBarBearish + // + && + // + // VWap Order ... + decisionConditions.x121Conditions.isVWapBearishOrdered + // + ; + + // + bool isDecisionPassed = isDecisionBullishPassed || + isDecisionBearishPassed; + result = isDecisionPassed; + if (!result) + { + return result; + } + + // + // Trigger ... + + // + double donOpenUpper = triggerConditions.x121Conditions.donOpenUpperBuffer[1]; + double donOpenLower = triggerConditions.x121Conditions.donOpenLowerBuffer[1]; + + // + double donCloseUpper = triggerConditions.x121Conditions.donCloseUpperBuffer[1]; + double donCloseLower = triggerConditions.x121Conditions.donCloseLowerBuffer[1]; + + // + bool isDonBullish = + // + donCloseLower > donOpenUpper + // + && + // + cBar.low > donCloseLower && + cBar.high > donCloseLower + // + ; + + // + bool isDonBearish = + // + donOpenUpper > donCloseUpper + // + && + // + cBar.low < donCloseUpper && + cBar.high < donCloseUpper + // + ; + + // + bool isTriggerBullishPassed = + // + // Don ... + isDonBullish + // + && + // + // Sar ... + triggerConditions.x121Conditions.isSarBullish + // + ; + + // + bool isTriggerBearishPassed = + // + // Don ... + isDonBearish + // + && + // + // Sar ... + triggerConditions.x121Conditions.isSarBearish + // + ; + + // + bool isTriggerPassed = isTriggerBullishPassed || + isTriggerBearishPassed; + result = isTriggerPassed; + if (!result) + { + return result; + } + + // + // + // + + // + bool isBullishTriggerConditionsPassed = + // + isConsolidationBullishPassed && + isVerificationBullishPassed && + isAnalyseBullishPassed && + isDecisionBullishPassed && + isTriggerBullishPassed + // + ; + + // + bool isBearishTriggerConditionsPassed = + // + isConsolidationBearishPassed && + isVerificationBearishPassed && + isAnalyseBearishPassed && + isDecisionBearishPassed && + isTriggerBearishPassed + // + ; + + // + // + // + + // + bool isBullish = + // + IsBullish(setupDir) && + hasConsolidationSupportZone && + isBullishTriggerConditionsPassed + // + ; + + // + bool isBearish = + // + IsBearish(setupDir) && + hasConsolidationResistanceZone && + isBearishTriggerConditionsPassed + // + ; + + // + result = + isBullish || + isBearish; + if (!result) + { + return result; + } + + // + double entry = GetEntry( + symbol, + setupDir // + ); + double spread = GetSpread( + symbol // + ); + + // + zoneValidationDivider = 8; + double selectedSL = isBullish + ? consolidationResistanceZone.Upper() - spread - + ((consolidationResistanceZone.Upper() - consolidationResistanceZone.Lower()) / + zoneValidationDivider) + : consolidationSupportZone.Lower() + spread + + ((consolidationSupportZone.Upper() - consolidationSupportZone.Lower()) / + zoneValidationDivider); + + // + mTestConditions.sl = selectedSL; + mTestConditions.type = + isBullish + ? X_POSITION_TYPE_LONG + : X_POSITION_TYPE_SHORT; + mTestConditions.triggerTime = TimeCurrent(); + } + + // + // Check Conditions is Prepared for Trigger ... + result = mTestConditions.CanTrigger(); + if (!result) + { + return result; + } + + // + conditions.signalDir = setupDir; + conditions.provider = providerStr; + conditions.sl = mTestConditions.sl; + + // + mTestConditions.Clean(); + + // + return result; + } + + +/////////////////////////////////////////////////////////////////////////////////////////////// + + // + // Detect Supply and Demand Zones inside Order Block ... + XCOrderBlock *orderBlock = NULL; + if (isNewPeakInsideBearihOrderBlock) + { + orderBlock = mTestConditions.bearishOrderBlock; + } + else + { + orderBlock = mTestConditions.bullishOrderBlock; + } + + // + // Supply Zone ... + XPOIState selectedState = visionState; + bool hasSupplyZone = mTestConditions.HasSupplyZone(); + int supplyZonesCount = selectedState.CountSupplyZones(); + if (!hasSupplyZone) + { + // + if (IsValidSize(supplyZonesCount)) + { + // + XCSupplyZone *supplyZones[]; + for (int i = 0; i < supplyZonesCount; i++) + { + // + XCSupplyZone *iZone = selectedState.supplyZones[i]; + + // + bool isValid = iZone.Upper() <= orderBlock.Upper() && + iZone.Lower() >= orderBlock.Lower(); + if (isValid) + { + // + Add( + iZone, + supplyZones // + ); + } + } + + // + XCSupplyZone *supply = NULL; + supplyZonesCount = ArraySize(supplyZones); + for (int i = 0; i < supplyZonesCount; i++) + { + // + XCSupplyZone *iZone = supplyZones[i]; + + // + bool isValid = supply == NULL + ? true + : supply.Upper() < iZone.Upper(); + if (isValid) + { + supply = iZone; + } + } + if (supply != NULL && supply.IsValid()) + { + mTestConditions.supplyZone = supply; + } + + // + hasSupplyZone = mTestConditions.HasSupplyZone(); + } + } + // + // TODO: Remove ... + else + { + // + mTestConditions.supplyZone.To(TimeCurrent()); + XCSupplyZoneObject *iObj; + bool isCreated = mPOIDrawer.CreateSupplyZone( + mTestConditions.supplyZone, + iObj // + ); + if (isCreated) + { + // + iObj.ZoneWidth(3); + + // + AddObjectIfNotExists(iObj); + } + } + + // + // Demand Zone ... + bool hasDemandZone = mTestConditions.HasDemandZone(); + int demandZonesCount = selectedState.CountDemandZones(); + if (!hasDemandZone) + { + // + if (IsValidSize(demandZonesCount)) + { + // + XCDemandZone *demandZones[]; + for (int i = 0; i < demandZonesCount; i++) + { + // + XCDemandZone *iZone = selectedState.demandZones[i]; + + // + bool isValid = iZone.Upper() <= orderBlock.Upper() && + iZone.Lower() >= orderBlock.Lower(); + if (isValid) + { + // + Add( + iZone, + demandZones // + ); + } + } + + // + XCDemandZone *demand = NULL; + demandZonesCount = ArraySize(demandZones); + for (int i = 0; i < demandZonesCount; i++) + { + // + XCDemandZone *iZone = demandZones[i]; + + // + bool isValid = demand == NULL + ? true + : demand.Upper() < iZone.Upper(); + if (isValid) + { + demand = iZone; + } + } + if (demand != NULL && demand.IsValid()) + { + mTestConditions.demandZone = demand; + } + + // + hasDemandZone = mTestConditions.HasDemandZone(); + } + } + // + // TODO: Remove ... + else + { + // + mTestConditions.demandZone.To(TimeCurrent()); + XCDemandZoneObject *iObj; + bool isCreated = mPOIDrawer.CreateDemandZone( + mTestConditions.demandZone, + iObj // + ); + if (isCreated) + { + // + iObj.ZoneWidth(3); + + // + AddObjectIfNotExists(iObj); + } + } + + + + // + // Supply and Demand Zone ... + XCSupplyZone *supplyZone; + XCDemandZone *demandZone; + + // + supplyZone = NULL; + demandZone = NULL; + + // + // Supply and Demand ... + + bool HasSupplyZone() + { + // + bool result = false; + + // + result = + // + supplyZone != NULL && + supplyZone.IsValid() + // + ; + + // + return result; + } + + bool HasDemandZone() + { + // + bool result = false; + + // + result = + // + demandZone != NULL && + demandZone.IsValid() + // + ; + + // + return result; + } + +//////////////////////////////////////////////////////////////////////////////////////////////// + + // else + // // + // // Draw ... + // { + // // + // // TODO: Remove this ... + + // // + // bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + // if (hasBullishOB) + // { + // // + // mTestConditions.bullishOrderBlock.To(TimeCurrent()); + // XCBullishOrderBlockObject *iObj; + // bool isCreated = mPOIDrawer.CreateBullishOrderBlock( + // mTestConditions.bullishOrderBlock, + // iObj // + // ); + // if (isCreated) + // { + // // + // iObj.ZoneWidth(4); + // iObj.ZoneColor(clrAqua); + + // // + // AddObjectIfNotExists(iObj); + // } + // } + + // // + // bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + // if (hasBearishOB) + // { + // // + // mTestConditions.bearishOrderBlock.To(TimeCurrent()); + // XCBearishOrderBlockObject *iObj; + // bool isCreated = mPOIDrawer.CreateBearishOrderBlock( + // mTestConditions.bearishOrderBlock, + // iObj // + // ); + // if (isCreated) + // { + // // + // iObj.ZoneWidth(4); + // iObj.ZoneColor(clrMagenta); + + // // + // AddObjectIfNotExists(iObj); + // } + // } + // } + + // + // Detect Supply and Demand Zone inside Order Block ... + +/////////////////////////////////////////////////////////////////////////////////////////////// + + + // + // TODO: Remove this ... + XSMCStrategySetupConditions mTestConditions; + bool DetectTestSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + bool isBullish = false; + bool isBearish = false; + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double selectedSL = 0; + + // + // Retrieve Peak and Vale ... + double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + + // + X121SMCCycleConditions triggerConditions = conditions.triggerConditions; + X121SMCCycleConditions decisionConditions = conditions.decisionConditions; + X121SMCCycleConditions analyseConditions = conditions.analyseConditions; + X121SMCCycleConditions verificationConditions = conditions.verificationConditions; + X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions; + X121SMCCycleConditions visionConditions = conditions.visionConditions; + + // + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + int zoneValidationDivider = 10; + + // + // Try to Detect Setup Conditions ... + result = mTestConditions.IsSetuped(); + + // + // Try to Validate if not Pssed ... + if (result) + { + // + bool canReset = false; + bool iBullish = IsBullish(mTestConditions.dir); + if (isBullish) + { + // + canReset = + // + bid < mTestConditions.bullishOrderBlock.Lower() && + ask < mTestConditions.bullishOrderBlock.Lower() && + cBar.high < mTestConditions.bullishOrderBlock.Lower() + // + ; + } + else + { + // + canReset = + // + bid < mTestConditions.bearishOrderBlock.Upper() && + ask < mTestConditions.bearishOrderBlock.Upper() && + cBar.high < mTestConditions.bearishOrderBlock.Upper() + // + ; + } + + // + if (canReset) + { + // + string message = providerStr + " Conditions Resetted ..."; + Alert(message); + mTestConditions.Clean(); + } + + // + result = mTestConditions.IsSetuped(); + } + + // + if (!result) + { + // + // Check has Order Block ... + bool hasOrderBlock = mTestConditions.HasOrderBlock(); + if (!hasOrderBlock) + { + // + // Detect Order Blocks ... + + // + // Bullish ... + bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + if (!hasBullishOB) + { + // + // Bullish ... + int bullishOBsCount = visionState.CountBullishOrderBlocks(); + if (IsValidSize(bullishOBsCount)) + { + // + XCOrderBlock *bullishOBs[]; + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bullishOrderBlocks[i]; + + // + bool isValid = cBar.low > iZone.Upper(); + if (isValid) + { + // + Add( + iZone, + bullishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bullishOBsCount = ArraySize(bullishOBs); + if (IsValidSize(bullishOBsCount)) + { + // + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = bullishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Upper() < iZone.Upper(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + mTestConditions.bullishOrderBlock = ob; + } + } + } + + // + // Bearish ... + bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + if (!hasBearishOB) + { + // + // Bearish ... + int bearishOBsCount = visionState.CountBearishOrderBlocks(); + if (IsValidSize(bearishOBsCount)) + { + // + XCOrderBlock *bearishOBs[]; + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bearishOrderBlocks[i]; + + // + bool isValid = cBar.high < iZone.Lower(); + if (isValid) + { + // + Add( + iZone, + bearishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bearishOBsCount = ArraySize(bearishOBs); + if (IsValidSize(bearishOBsCount)) + { + // + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = bearishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Lower() > iZone.Lower(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + mTestConditions.bearishOrderBlock = ob; + } + } + } + + // + result = mTestConditions.HasOrderBlock(); + if (!result) + { + return result; + } + } + + // + // Wait for new Vale or Peaks ... + double visionPeak = visionConditions.x121Conditions.peaksBuffer[0]; + double visionVale = visionConditions.x121Conditions.valesBuffer[0]; + bool isNewVisionPeak = visionConditions.x121Conditions.isNewPeak; + bool isNewVisionVale = visionConditions.x121Conditions.isNewVale; + + // + bool isNewPeakInsideBearihOrderBlock = + // + isNewVisionPeak && + visionPeak > mTestConditions.bearishOrderBlock.Lower() && + visionPeak < mTestConditions.bearishOrderBlock.Upper() + // + ; + + // + bool isNewValeInsideBullishOrderBlock = + // + isNewVisionVale && + visionVale > mTestConditions.bullishOrderBlock.Lower() && + visionVale < mTestConditions.bullishOrderBlock.Upper() + // + ; + + // + result = isNewPeakInsideBearihOrderBlock || + isNewValeInsideBullishOrderBlock; + if (!result) + { + return result; + } + + // + // Lookig for a Valid Peaks and Vales Formes ... + // Peaks Inside Bearish Order Block ... + // Vales inside Bullish Order Block ... + + // + int validPivotRepetition = mTriggerCycleHelper.mX121Helper + .GetDonChainLength(); + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[0]; + + // + // Valid Peaks ... + XPVPivotPoint validPeak; + XPVPivotPoint peaksChanges[]; + int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges); + if (IsValidSize(peaksChangesCount)) + { + validPeak = peaksChanges[peaksChangesCount - 1]; + } + + // + // Valid Vales ... + XPVPivotPoint validVale; + XPVPivotPoint valesChanges[]; + int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges); + if (IsValidSize(valesChangesCount)) + { + validVale = valesChanges[valesChangesCount - 1]; + } + + // + bool hasValidPeak = (validPeak.IsValid() && + validPeak.value < mTestConditions.bearishOrderBlock.Upper() && + validPeak.value > mTestConditions.bearishOrderBlock.Lower()); + + // + bool hasValidVale = (validVale.IsValid() && + validVale.value < mTestConditions.bullishOrderBlock.Upper() && + validVale.value > mTestConditions.bullishOrderBlock.Lower()); + + // + result = hasValidPeak || + hasValidVale; + if (!result) + { + return result; + } + + // + if (hasValidPeak) + { + mTestConditions.validPeak = validPeak; + } + if (hasValidVale) + { + mTestConditions.validVale = validVale; + } + + // + bool isBullish = + // + hasValidVale && + isNewValeInsideBullishOrderBlock + // + ; + + // + bool isBearish = + // + hasValidPeak && + isNewPeakInsideBearihOrderBlock + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + mTestConditions.dir = isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + mTestConditions.setupTime = TimeCurrent(); + + // + result = mTestConditions.IsSetuped(); + if (!result) + { + return result; + } + + // + // Alert ... + string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir); + Alert(message); + } + else + { + // + // Waits for Sar Change Under Valid Value or Above Valid Peak ... + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[1]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[1]; + double triggerSar = triggerConditions.x121Conditions.sarBuffer[1]; + bool isSarSwitchedToBullish = triggerConditions.x121Conditions.isSarSwitchedToBullish; + bool isSarSwitchedToBearish = triggerConditions.x121Conditions.isSarSwitchedToBearish; + + // + bool isBullish = + // + isSarSwitchedToBullish && + triggerSar == triggerVale && + IsBullish(mTestConditions.dir) && + mTestConditions.validVale.IsValid() && + triggerSar < mTestConditions.validVale.value + // + ; + + // + bool isBearish = + // + isSarSwitchedToBearish && + triggerSar == triggerPeak && + IsBearish(mTestConditions.dir) && + mTestConditions.validPeak.IsValid() && + triggerSar < mTestConditions.validPeak.value + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + // Try to Detect Trigger Conditions ... + + // + mTestConditions.symbol = symbol; + mTestConditions.period = period; + + // + mTestConditions.Clean(); + } + + // + // Check Conditions is Prepared for Trigger ... + result = mTestConditions.CanTrigger(); + if (!result) + { + return result; + } + + // + conditions.signalDir = mTestConditions.dir; + conditions.provider = providerStr; + conditions.sl = mTestConditions.sl; + + // + mTestConditions.Clean(); + + // + return result; + } + + +///////////////////////////////////////////////////////////////////////////////////////// + + + + // + // TODO: Remove this ... + XSMCStrategySetupConditions mTestConditions; + bool DetectTestSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + bool isBullish = false; + bool isBearish = false; + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double selectedSL = 0; + + // + // Retrieve Peak and Vale ... + double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + + // + X121SMCCycleConditions triggerConditions = conditions.triggerConditions; + X121SMCCycleConditions decisionConditions = conditions.decisionConditions; + X121SMCCycleConditions analyseConditions = conditions.analyseConditions; + X121SMCCycleConditions verificationConditions = conditions.verificationConditions; + X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions; + X121SMCCycleConditions visionConditions = conditions.visionConditions; + + // + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + int zoneValidationDivider = 10; + + // + // Try to Detect Setup Conditions ... + result = mTestConditions.IsSetuped(); + + // + // Try to Validate if not Pssed ... + if (result) + { + // + bool canReset = false; + bool iBullish = IsBullish(mTestConditions.dir); + if (isBullish) + { + // + canReset = + // + bid < mTestConditions.bullishOrderBlock.Lower() && + ask < mTestConditions.bullishOrderBlock.Lower() && + cBar.high < mTestConditions.bullishOrderBlock.Lower() + // + ; + } + else + { + // + canReset = + // + bid < mTestConditions.bearishOrderBlock.Upper() && + ask < mTestConditions.bearishOrderBlock.Upper() && + cBar.high < mTestConditions.bearishOrderBlock.Upper() + // + ; + } + + // + if (canReset) + { + // + string message = providerStr + " Conditions Resetted ..."; + Alert(message); + mTestConditions.Clean(); + } + + // + result = mTestConditions.IsSetuped(); + } + + // + if (!result) + { + // + // Check has Order Block ... + bool hasOrderBlock = mTestConditions.HasOrderBlock(); + if (!hasOrderBlock) + { + // + // Detect Order Blocks ... + + // + // Bullish ... + bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + if (!hasBullishOB) + { + // + // Bullish ... + int bullishOBsCount = visionState.CountBullishOrderBlocks(); + if (IsValidSize(bullishOBsCount)) + { + // + XCOrderBlock *bullishOBs[]; + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bullishOrderBlocks[i]; + + // + bool isValid = cBar.low > iZone.Upper(); + if (isValid) + { + // + Add( + iZone, + bullishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bullishOBsCount = ArraySize(bullishOBs); + if (IsValidSize(bullishOBsCount)) + { + // + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = bullishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Upper() < iZone.Upper(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + mTestConditions.bullishOrderBlock = ob; + } + } + } + + // + // Bearish ... + bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + if (!hasBearishOB) + { + // + // Bearish ... + int bearishOBsCount = visionState.CountBearishOrderBlocks(); + if (IsValidSize(bearishOBsCount)) + { + // + XCOrderBlock *bearishOBs[]; + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bearishOrderBlocks[i]; + + // + bool isValid = cBar.high < iZone.Lower(); + if (isValid) + { + // + Add( + iZone, + bearishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bearishOBsCount = ArraySize(bearishOBs); + if (IsValidSize(bearishOBsCount)) + { + // + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = bearishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Lower() > iZone.Lower(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + mTestConditions.bearishOrderBlock = ob; + } + } + } + + // + result = mTestConditions.HasOrderBlock(); + if (!result) + { + return result; + } + } + + // + // Wait for new Vale or Peaks ... + double visionPeak = visionConditions.x121Conditions.peaksBuffer[0]; + double visionVale = visionConditions.x121Conditions.valesBuffer[0]; + bool isNewVisionPeak = visionConditions.x121Conditions.isNewPeak; + bool isNewVisionVale = visionConditions.x121Conditions.isNewVale; + + // + bool isNewPeakInsideBearihOrderBlock = + // + isNewVisionPeak && + visionPeak > mTestConditions.bearishOrderBlock.Lower() && + visionPeak < mTestConditions.bearishOrderBlock.Upper() + // + ; + + // + bool isNewValeInsideBullishOrderBlock = + // + isNewVisionVale && + visionVale > mTestConditions.bullishOrderBlock.Lower() && + visionVale < mTestConditions.bullishOrderBlock.Upper() + // + ; + + // + result = isNewPeakInsideBearihOrderBlock || + isNewValeInsideBullishOrderBlock; + if (!result) + { + return result; + } + + // + // Lookig for a Valid Peaks and Vales Formes ... + // Peaks Inside Bearish Order Block ... + // Vales inside Bullish Order Block ... + + // + int validPivotRepetition = mTriggerCycleHelper.mX121Helper + .GetDonChainLength(); + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[0]; + + // + // Valid Peaks ... + XPVPivotPoint validPeak; + XPVPivotPoint peaksChanges[]; + int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges); + if (IsValidSize(peaksChangesCount)) + { + validPeak = peaksChanges[peaksChangesCount - 1]; + } + + // + // Valid Vales ... + XPVPivotPoint validVale; + XPVPivotPoint valesChanges[]; + int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges); + if (IsValidSize(valesChangesCount)) + { + validVale = valesChanges[valesChangesCount - 1]; + } + + // + bool hasValidPeak = (validPeak.IsValid() && + validPeak.value < mTestConditions.bearishOrderBlock.Upper() && + validPeak.value > mTestConditions.bearishOrderBlock.Lower()); + + // + bool hasValidVale = (validVale.IsValid() && + validVale.value < mTestConditions.bullishOrderBlock.Upper() && + validVale.value > mTestConditions.bullishOrderBlock.Lower()); + + // + result = hasValidPeak || + hasValidVale; + if (!result) + { + return result; + } + + // + if (hasValidPeak) + { + mTestConditions.validPeak = validPeak; + } + if (hasValidVale) + { + mTestConditions.validVale = validVale; + } + + // + bool isBullish = + // + hasValidVale && + isNewValeInsideBullishOrderBlock + // + ; + + // + bool isBearish = + // + hasValidPeak && + isNewPeakInsideBearihOrderBlock + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + mTestConditions.dir = isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + mTestConditions.setupTime = TimeCurrent(); + + // + result = mTestConditions.IsSetuped(); + if (!result) + { + return result; + } + + // + // Alert ... + string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir); + Alert(message); + } + else + { + // + // Waits for Sar Change Under Valid Value or Above Valid Peak ... + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[1]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[1]; + double triggerSar = triggerConditions.x121Conditions.sarBuffer[1]; + bool isSarSwitchedToBullish = triggerConditions.x121Conditions.isSarSwitchedToBullish; + bool isSarSwitchedToBearish = triggerConditions.x121Conditions.isSarSwitchedToBearish; + + // + bool isBullish = + // + isSarSwitchedToBullish && + triggerSar == triggerVale && + IsBullish(mTestConditions.dir) && + mTestConditions.validVale.IsValid() && + triggerSar < mTestConditions.validVale.value + // + ; + + // + bool isBearish = + // + isSarSwitchedToBearish && + triggerSar == triggerPeak && + IsBearish(mTestConditions.dir) && + mTestConditions.validPeak.IsValid() && + triggerSar < mTestConditions.validPeak.value + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + // Try to Detect Trigger Conditions ... + + // + mTestConditions.symbol = symbol; + mTestConditions.period = period; + + // + mTestConditions.Clean(); + } + + // + // Check Conditions is Prepared for Trigger ... + result = mTestConditions.CanTrigger(); + if (!result) + { + return result; + } + + // + conditions.signalDir = mTestConditions.dir; + conditions.provider = providerStr; + conditions.sl = mTestConditions.sl; + + // + mTestConditions.Clean(); + + // + return result; + } + + +///////////////////////////////////////////////////////////////////////////// + + + // + // TODO: Remove this ... + XSMCStrategySetupConditions mTestConditions; + bool DetectTestSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + bool isBullish = false; + bool isBearish = false; + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double selectedSL = 0; + + // + // Retrieve Peak and Vale ... + double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + + // + X121SMCCycleConditions triggerConditions = conditions.triggerConditions; + X121SMCCycleConditions decisionConditions = conditions.decisionConditions; + X121SMCCycleConditions analyseConditions = conditions.analyseConditions; + X121SMCCycleConditions verificationConditions = conditions.verificationConditions; + X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions; + X121SMCCycleConditions visionConditions = conditions.visionConditions; + + // + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + int zoneValidationDivider = 10; + int validPivotRepetition = mTriggerCycleHelper.mX121Helper + .GetDonChainLength(); + + // + // Check Setting Upped ... + result = mTestConditions.IsSetuped(); + + // + // Try to Validate if not Pssed ... + if (result) + { + // + double upper = 0; + double lower = 0; + + // + double hh = cBar.FindHighest(9, MODE_HIGH); + double ll = cBar.FindLowest(9, MODE_LOW); + + // + bool canReset = false; + isBullish = IsBullish(mTestConditions.dir); + if (isBullish) + { + // + upper = mTestConditions.bullishOrderBlock.Upper(); + lower = mTestConditions.bullishOrderBlock.Lower(); + + // + canReset = + // + (ll > upper && + bid > upper && + ask > upper) + // + || + // + (hh < lower && + bid < lower && + ask < lower) + // + ; + } + else + { + // + upper = mTestConditions.bearishOrderBlock.Upper(); + lower = mTestConditions.bearishOrderBlock.Lower(); + + // + canReset = + // + (hh < lower && + bid < lower && + ask < lower) + // + || + // + (ll > upper && + bid > upper && + ask > upper) + // + ; + } + + // + if (canReset) + { + // + string message = providerStr + " Conditions Resetted ..."; + Alert(message); + + // + ClearDraws(); + mTestConditions.Clean(); + } + + // + result = mTestConditions.IsSetuped(); + } + + // + // Try to Detect Setting Up Conditions ... + if (!result) + { + // + // Check has Order Block ... + bool hasOrderBlock = mTestConditions.HasOrderBlock(); + if (!hasOrderBlock) + { + // + // Detect Order Blocks ... + + // + // Bullish ... + bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + if (!hasBullishOB) + { + // + // Bullish ... + int bullishOBsCount = visionState.CountBullishOrderBlocks(); + if (IsValidSize(bullishOBsCount)) + { + // + XCOrderBlock *bullishOBs[]; + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bullishOrderBlocks[i]; + + // + bool isValid = cBar.low > iZone.Upper(); + if (isValid) + { + // + Add( + iZone, + bullishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bullishOBsCount = ArraySize(bullishOBs); + if (IsValidSize(bullishOBsCount)) + { + // + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = bullishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Upper() < iZone.Upper(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + // + mTestConditions.bullishOrderBlock = ob; + mTestConditions.bullishOrderBlockTime = TimeCurrent(); + } + } + } + + // + // Bearish ... + bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + if (!hasBearishOB) + { + // + // Bearish ... + int bearishOBsCount = visionState.CountBearishOrderBlocks(); + if (IsValidSize(bearishOBsCount)) + { + // + XCOrderBlock *bearishOBs[]; + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = visionState.bearishOrderBlocks[i]; + + // + bool isValid = cBar.high < iZone.Lower(); + if (isValid) + { + // + Add( + iZone, + bearishOBs // + ); + } + } + + // + XCOrderBlock *ob = NULL; + bearishOBsCount = ArraySize(bearishOBs); + if (IsValidSize(bearishOBsCount)) + { + // + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = bearishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Lower() > iZone.Lower(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if (ob != NULL && ob.IsValid()) + { + // + mTestConditions.bearishOrderBlock = ob; + mTestConditions.bearishOrderBlockTime = TimeCurrent(); + } + } + } + + // + hasOrderBlock = mTestConditions.HasOrderBlock(); + result = hasOrderBlock; + if (!result) + { + return result; + } + } + else + { + // + datetime nearestTime = NULL; + + // + bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + if (hasBullishOB) + { + // + nearestTime = + !IsValid(nearestTime) + ? mTestConditions.bullishOrderBlockTime + : nearestTime < mTestConditions.bullishOrderBlockTime + ? mTestConditions.bullishOrderBlockTime + : nearestTime; + + // + mTestConditions.bullishOrderBlock.To(TimeCurrent()); + XCBullishOrderBlockObject *iObj; + bool isCreated = mPOIDrawer.CreateBullishOrderBlock( + mTestConditions.bullishOrderBlock, + iObj // + ); + if (isCreated) + { + // + iObj.ZoneWidth(4); + iObj.ZoneColor(clrAqua); + + // + AddObjectIfNotExists(iObj); + } + } + + // + bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + if (hasBearishOB) + { + // + nearestTime = + !IsValid(nearestTime) + ? mTestConditions.bearishOrderBlockTime + : nearestTime < mTestConditions.bearishOrderBlockTime + ? mTestConditions.bearishOrderBlockTime + : nearestTime; + + // + mTestConditions.bearishOrderBlock.To(TimeCurrent()); + XCBearishOrderBlockObject *iObj; + bool isCreated = mPOIDrawer.CreateBearishOrderBlock( + mTestConditions.bearishOrderBlock, + iObj // + ); + if (isCreated) + { + // + iObj.ZoneWidth(4); + iObj.ZoneColor(clrMagenta); + + // + AddObjectIfNotExists(iObj); + } + } + + // + if (IsValid(nearestTime)) + { + // + datetime cTime = TimeCurrent(); + int periodSeconds = PeriodSeconds(period); + int passedTime = (int)cTime - (int)nearestTime; + + // + int barsPassed = passedTime / periodSeconds; + bool canReset = barsPassed >= validPivotRepetition * 5; + if (canReset && + !mTestConditions.isOrderBlockAttacked) + { + // + ClearDraws(); + mTestConditions.Clean(); + result = false; + + // + return result; + } + } + } + + // + // Check Order Block Attacks ... + if (!mTestConditions.isOrderBlockAttacked) + { + // + bool isBullishOrderBlockAttacked = + // + (mTestConditions.HasBullishOrderBlock() && + cBar.high < mTestConditions.bullishOrderBlock.Upper() && + cBar.low > mTestConditions.bullishOrderBlock.Lower()) + // + ; + bool isBearishOrderBlockAttacked = + // + (mTestConditions.HasBearishOrderBlock() && + cBar.high < mTestConditions.bearishOrderBlock.Upper() && + cBar.low > mTestConditions.bearishOrderBlock.Lower()) + // + ; + bool isOrderBlockAttacked = isBullishOrderBlockAttacked || + isBearishOrderBlockAttacked; + result = isOrderBlockAttacked; + if (!result) + { + return result; + } + + // + mTestConditions.isOrderBlockAttacked = isOrderBlockAttacked; + } + + // + // Other Conditions ... + bool isNewTriggerPeak = triggerConditions.x121Conditions.isNewPeak; + bool isNewTriggerVale = triggerConditions.x121Conditions.isNewVale; + + // + bool isNewPeakInsideBearihOrderBlock = + // + isNewTriggerPeak && + triggerPeak > mTestConditions.bearishOrderBlock.Lower() && + triggerPeak < mTestConditions.bearishOrderBlock.Upper() + // + ; + + // + bool isNewValeInsideBullishOrderBlock = + // + isNewTriggerVale && + triggerVale > mTestConditions.bullishOrderBlock.Lower() && + triggerVale < mTestConditions.bullishOrderBlock.Upper() + // + ; + + // + result = isNewPeakInsideBearihOrderBlock || + isNewValeInsideBullishOrderBlock; + if (!result) + { + return result; + } + + // + // Lookig for a Valid Peaks and Vales Formes ... + // Peaks Inside Bearish Order Block ... + // Vales inside Bullish Order Block ... + + // + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[0]; + + // + // Valid Peaks ... + XPVPivotPoint validPeak; + XPVPivotPoint peaksChanges[]; + int peaksChangesCount = mTriggerCycleHelper.FillPeakPivotPoints(peaksChanges); + if (IsValidSize(peaksChangesCount)) + { + validPeak = peaksChanges[peaksChangesCount - 1]; + } + + // + // Valid Vales ... + XPVPivotPoint validVale; + XPVPivotPoint valesChanges[]; + int valesChangesCount = mTriggerCycleHelper.FillValePivotPoints(valesChanges); + if (IsValidSize(valesChangesCount)) + { + validVale = valesChanges[valesChangesCount - 1]; + } + + // + bool hasValidPeak = (validPeak.IsValid() && + validPeak.value < mTestConditions.bearishOrderBlock.Upper() && + validPeak.value > mTestConditions.bearishOrderBlock.Lower()); + + // + bool hasValidVale = (validVale.IsValid() && + validVale.value < mTestConditions.bullishOrderBlock.Upper() && + validVale.value > mTestConditions.bullishOrderBlock.Lower()); + + // + result = hasValidPeak || + hasValidVale; + if (!result) + { + return result; + } + + // + if (hasValidPeak) + { + mTestConditions.validPeak = validPeak; + } + if (hasValidVale) + { + mTestConditions.validVale = validVale; + } + + // + isBullish = + // + hasValidVale && + isNewValeInsideBullishOrderBlock + // + ; + + // + isBearish = + // + hasValidPeak && + isNewPeakInsideBearihOrderBlock + // + ; + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + ENUM_X_DIRECTION setupDir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + mTestConditions.dir = setupDir; + mTestConditions.setupTime = TimeCurrent(); + + // + // Alert ... + string message = providerStr + " Conditions Set Upped: " + ToString(mTestConditions.dir); + Alert(message); + } + + // + // Try To Detect Trigger Conditions ... + + // + // Check Conditions is Prepared for Trigger ... + result = mTestConditions.CanTrigger(); + if (!result) + { + return result; + } + + // + // Issues Signal on Conditions ... + conditions.signalDir = mTestConditions.dir; + conditions.provider = providerStr; + conditions.sl = mTestConditions.sl; + + // + // mTestConditions.Clean(); + + // + return result; + } + + +////////////////////////////////////////////////////////////////////////////////// + + + /** + * Detect and Parse Market Conditions for Signalling ... + * + * @param conditions: X121SMCStrategyConditions instance Reference ... + * + * @return ( bool ) + */ + bool DetectSamePeaksAndValesSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + string msg = NULL; + + // + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double selectedSL = 0; + + // + // Here We Select Cycles For Conditions Check ... + ENUM_X_CYCLES cycles[5] = { + X_CYCLE_TRIGGER, + X_CYCLE_DECISION, + X_CYCLE_ANALYSE, + X_CYCLE_VERIFICATION, + X_CYCLE_CONSOLIDATION // + }; + bool hasSamePeaks = DetectSamePeaks( + cycles, + conditions // + ); + bool hasSameVales = DetectSameVales( + cycles, + conditions // + ); + result = + hasSamePeaks || + hasSameVales; + if (!result) + { + return result; + } + + // + // Check Peaks And Vales Order ... + bool hasPeakBreak = false; + bool hasValeBreak = false; + + // + // Retrieve Last Sar Change ... + XOHCL cSarChangeBar; + XOHCL pSarChangeBar; + XValueChange cSarChange; // Current Sar Change (IsDirect) ... + XValueChange pSarChange; // Prev Sar Change (Direct) ... + XValueChange sarChanges[]; + int sarChangesCount = mTriggerCycleHelper + .FillSarChanges(sarChanges); + if (IsValidSize(sarChangesCount) && + sarChangesCount > 2) + { + // + cSarChange = sarChanges[sarChangesCount - 1]; + pSarChange = sarChanges[sarChangesCount - 2]; + + // + result = cSarChange.FillBar( + cSarChangeBar, + symbol, + period // + ); + if (!result) + { + return result; + } + + // + result = pSarChange.FillBar( + pSarChangeBar, + symbol, + period // + ); + if (!result) + { + return result; + } + + // + int start = cSarChangeBar.Index(); + int end = pSarChangeBar.Index(); + for (int i = start; i < end; i++) + { + // + ENUM_X_CYCLE_EVENTS iEvents[]; + X121SMCCycleConditions iConditions; + result = mTriggerCycleHelper.GetConditions( + iEvents, + iConditions, + i // + ); + if (!result) + { + continue; + } + + // + hasPeakBreak = + iConditions.x121Conditions.isNewPeakOverLast; + hasValeBreak = + iConditions.x121Conditions.isNewValeUnderLast; + result = hasPeakBreak || + hasValeBreak; + if (result) + { + break; + } + } + } + if (!result) + { + return result; + } + + // + // Check Sar State ... + ENUM_X_DIRECTION sarDir; + result = DetectSarState( + provider, + sarDir, + conditions // + ); + if (!result) + { + return result; + } + + // + // Check VWAP State ... + ENUM_X_DIRECTION vwapDir; + result = DetectVWapState( + provider, + vwapDir, + conditions // + ); + if (!result) + { + return result; + } + + // + // Detect a Valid Peaks Break ... + + // + // Find Supply and Demand Zones ... + // XPOIState state = conditions.visionConditions.state; + // int supplyZonesCount = + + // + bool isBullish = + // + hasSamePeaks && + hasPeakBreak && + IsBullish(sarDir) && + IsBullish(vwapDir) + // + ; + + // + bool isBearish = + // + hasSameVales && + hasValeBreak && + IsBearish(sarDir) && + IsBearish(vwapDir) + // + ; + + // + result = + isBullish || + isBearish; + if (!result) + { + return result; + } + + // + CustomStateDrawing( + conditions.visionConditions.state, + false, // + X_DIRECTION_NONE, + false, // ignoreSwingHighs + false, // ignoreSwingLows + true, // ignoreSupportZones + true, // ignoreResistanceZones + false, // ignoreSupplyZones + false, // ignoreDemandZones + true, // ignoreBullishOrderBlocks + true, // ignoreBearishOrderBlocks + true, // ignoreBullishFairValueGaps + true, // ignoreBearishFairValueGaps + true, // ignoreBullishRejectionBars + true, // ignoreBearishRejectionBars + true, // ignoreBullishMomentumBars + true // ignoreBearishMomentumBars + ); + + // + // Set SL, Provider and Direction ... + conditions.signalDir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + conditions.provider = providerStr; + + // + // Selectiong SL ... + double selectedSLRJ = SelectSL( + conditions, + conditions.signalDir, + X_121_SMC_SL_TYPE_REJECTION // + ); + double selectedSLMN = SelectSL( + conditions, + conditions.signalDir, + X_121_SMC_SL_TYPE_MOMENTUM // + ); + double selectedSLSW = SelectSL( + conditions, + conditions.signalDir, + X_121_SMC_SL_TYPE_SWING // + ); + double selectedSLSR = SelectSL( + conditions, + conditions.signalDir, + X_121_SMC_SL_TYPE_CURRENT_SAR // + ); + + // + double slCandidates[4] = { + selectedSLRJ, + selectedSLMN, + selectedSLSW, + selectedSLSR // + }; + selectedSL = isBullish + ? GetMin(slCandidates) + : GetMax(slCandidates); + + // + // Normalizing SL ... + double entry = GetEntry( + symbol, + conditions.signalDir // + ); + double pip = GetPipPrice(symbol); + double spread = GetSpread(symbol); + double points = GetPoints(symbol); + + // + if (isBullish && selectedSL <= entry) + { + selectedSL -= (points * 30) - spread; + } + else if (isBearish && selectedSL >= entry) + { + selectedSL += (points * 30) + spread; + } + + // + // Detect SL and TP ... + conditions.sl = selectedSL; + + // + return result; + } + + /** + * Detect and Parse Market Conditions for Signalling ... + * + * @param conditions: X121SMCStrategyConditions instance Reference ... + * + * @return ( bool ) + */ + bool DetectRJBPVSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + 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; + } + + // + string msg = NULL; + + // + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_RJBPV; + string providerStr = ToString(provider); + + // + // Bar High Eqauls to Peaks or Vale ... + double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[2]; + double vale = conditions.triggerConditions.x121Conditions.valesBuffer[2]; + bool isNewPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[2] != conditions.triggerConditions.x121Conditions.peaksBuffer[3]; + bool isNewVale = conditions.triggerConditions.x121Conditions.valesBuffer[2] != conditions.triggerConditions.x121Conditions.valesBuffer[3]; + bool isClosedUnderDonCloseUpper = cBar.close < + conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[1]; + bool isClosedOverDonCloseLower = cBar.close > + conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[1]; + bool isSarBullish = + zBar.low > conditions.triggerConditions.x121Conditions.sarBuffer[0]; + bool isSarBearish = + zBar.high < conditions.triggerConditions.x121Conditions.sarBuffer[0]; + + // + // XPVPivot orderFlow[]; + // ENUM_X_DIRECTION orderFlowDir; + // mTriggerCycleHelper + // .DetectOrderFlow( + // zIndex, + // orderFlow, + // orderFlowDir // + // ); + // int pivotsCount = ArraySize(orderFlow); + // result = IsValidSize(pivotsCount); + // if (!result) + // { + // return result; + // } + // XPVPivot lastPivot = orderFlow[pivotsCount - 1]; + + // + double zoneVerificationDivider = 10; + bool isPeakInsideSupplyZone = false; + bool isValeInsideDemandZone = false; + + // + XPOIState state = conditions.verificationConditions.state; + + // // + // // Detect Order Block ... + // XCOrderBlock *orderBlock = NULL; + + // // + // int bullishOBCount = state.CountBullishOrderBlocks(); + // if (IsValidSize(bullishOBCount)) + // { + // // + // for (int i = 0; i < bullishOBCount; i++) + // { + // // + // XCOrderBlock *iZone = state.bullishOrderBlocks[i]; + + // // + // bool isInside = vale >= iZone.Lower() && + // vale <= iZone.Upper() && + // bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); + // if (isInside) + // { + // // + // orderBlock = iZone; + // break; + // } + // } + // } + + // // + // int bearishOBCount = state.CountBearishOrderBlocks(); + // if (IsValidSize(bearishOBCount)) + // { + // // + // for (int i = 0; i < bearishOBCount; i++) + // { + // // + // XCOrderBlock *iZone = state.bearishOrderBlocks[i]; + + // // + // bool isInside = peak >= iZone.Lower() && + // peak <= iZone.Upper() && + // bid >= iZone.Upper() - ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); + // if (isInside) + // { + // // + // orderBlock = iZone; + // break; + // } + // } + // } + + // // + // result = orderBlock != NULL && + // orderBlock.IsValid(); + // if (!result) + // { + // return result; + // } + + // // + // // Draw Order Block ... + // orderBlock.To(TimeCurrent()); + // if (orderBlock.IsBullish()) + // { + // // + // XCBullishOrderBlockObject *iObj; + // bool isCreated = mPOIDrawer.CreateBullishOrderBlock( + // orderBlock, + // iObj // + // ); + // if (isCreated) + // { + // AddObjectIfNotExists(iObj); + // } + // } + // else + // { + // // + // XCBearishOrderBlockObject *iObj; + // bool isCreated = mPOIDrawer.CreateBearishOrderBlock( + // orderBlock, + // iObj // + // ); + // if (isCreated) + // { + // AddObjectIfNotExists(iObj); + // } + // } + + // + XCSupplyZone *supplyZone; + int supplyCount = state.CountSupplyZones(); + if (IsValidSize(supplyCount)) + { + // + for (int i = 0; i < supplyCount; i++) + { + // + XCSupplyZone *iZone = state.supplyZones[i]; + isPeakInsideSupplyZone = peak >= iZone.Lower() && + peak <= iZone.Upper() && + bid >= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); + if (isPeakInsideSupplyZone) + { + // + supplyZone = iZone; + break; + } + } + } + + // + XCDemandZone *demandZone; + int demandCount = state.CountDemandZones(); + if (IsValidSize(demandCount)) + { + // + for (int i = 0; i < demandCount; i++) + { + // + XCDemandZone *iZone = state.demandZones[i]; + isValeInsideDemandZone = vale >= iZone.Lower() && + vale <= iZone.Upper() && + bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); + if (isValeInsideDemandZone) + { + // + demandZone = iZone; + break; + } + } + } + + // + bool isPeakAttacked = + isNewPeak && + isSarBearish && + pBar.high == peak && + isPeakInsideSupplyZone && + isClosedUnderDonCloseUpper; + + // + bool isValeAttacked = + isNewVale && + isSarBullish && + pBar.low == vale && + isValeInsideDemandZone && + isClosedOverDonCloseLower; + + // + result = isPeakAttacked || + isValeAttacked; + if (!result) + { + return result; + } + + // + if (isPeakAttacked) + { + // + supplyZone.To(TimeCurrent()); + XCSupplyZoneObject *iObj; + bool isCreated = mPOIDrawer.CreateSupplyZone( + supplyZone, + iObj // + ); + if (isCreated) + { + AddObjectIfNotExists(iObj); + } + } + else + { + // + demandZone.To(TimeCurrent()); + XCDemandZoneObject *iObj; + bool isCreated = mPOIDrawer.CreateDemandZone( + demandZone, + iObj // + ); + if (isCreated) + { + AddObjectIfNotExists(iObj); + } + } + + // + bool isBullish = + // + isValeAttacked + // + ; + + // + bool isBearish = + // + isPeakAttacked + // + ; + + // + result = + // + isBullish || + isBearish + // + ; + if (!result) + { + return result; + } + + // + // Set SL, Provider and Direction ... + conditions.signalDir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + conditions.provider = providerStr; + + // + conditions.sl = + isBullish + ? demandZone.Lower() + : supplyZone.Upper(); + + // + return result; + } + + /** + * Detect and Parse Market Conditions for Signalling ... + * + * @param conditions: X121SMCStrategyConditions instance Reference ... + * + * @return ( bool ) + */ + // TODO: Required Calibrate ... + bool DetectVWAPCSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + return false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + string msg = NULL; + + // + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_VWAPC; + string providerStr = ToString(provider); + + // + // Check Candlestic State ... + ENUM_X_DIRECTION candlesticDir; + result = DetectCandlestic( + provider, + candlesticDir, + conditions // + ); + if (!result) + { + return result; + } + + // + // Check Sar State ... + ENUM_X_DIRECTION sarDir; + result = DetectSarState( + provider, + sarDir, + conditions // + ); + if (!result) + { + return result; + } + + // + // Check VWAP State ... + ENUM_X_DIRECTION vwapDir; + result = DetectVWapState( + provider, + vwapDir, + conditions // + ); + if (!result) + { + return result; + } + + // + bool isBullish = + // + IsBullish(sarDir) && + IsBullish(vwapDir) && + IsBullish(candlesticDir) + // + ; + + // + bool isBearish = + // + IsBearish(sarDir) && + IsBearish(vwapDir) && + IsBearish(candlesticDir) + // + ; + + // + result = + // + isBullish || + isBearish + // + ; + + // + Print("VWap Signal ..."); + + // + if (!result) + { + return result; + } + + // + return result; + } + + + + /** + * Detect Where Cycles has Same Peaks ... + * + * @param cycles: ENUM_X_CYCLES members, Array ... + * @param conditions: X121SMCStrategyConditions instance, Reference ... + * + * @return ( bool ) + */ + bool DetectSamePeaks( + ENUM_X_CYCLES &cycles[], + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + int count = ArraySize(cycles); + result = IsValidSize(count); + if (!result) + { + return result; + } + + // + double value = -1; + for (int i = 0; i < count; i++) + { + // + ENUM_X_CYCLES iCycle = cycles[i]; + + // + double iValue = -1; + switch (iCycle) + { + // + case X_CYCLE_TRIGGER: + iValue = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + break; + + // + case X_CYCLE_DECISION: + iValue = conditions.decisionConditions.x121Conditions.peaksBuffer[0]; + break; + + // + case X_CYCLE_ANALYSE: + iValue = conditions.analyseConditions.x121Conditions.peaksBuffer[0]; + break; + + // + case X_CYCLE_VERIFICATION: + iValue = conditions.verificationConditions.x121Conditions.peaksBuffer[0]; + break; + + // + case X_CYCLE_CONSOLIDATION: + iValue = conditions.consolidationConditions.x121Conditions.peaksBuffer[0]; + break; + + // + case X_CYCLE_VISION: + iValue = conditions.visionConditions.x121Conditions.peaksBuffer[0]; + break; + } + + // + if (iValue > 0) + { + // + if (value <= 0) + { + value = iValue; + } + + // + result = value == iValue; + if (!result) + { + break; + } + } + } + + // + return result; + } + + /** + * Detect Where Cycles has Same Vales ... + * + * @param cycles: ENUM_X_CYCLES members, Array ... + * @param conditions: X121SMCStrategyConditions instance, Reference ... + * + * @return ( bool ) + */ + bool DetectSameVales( + ENUM_X_CYCLES &cycles[], + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + int count = ArraySize(cycles); + result = IsValidSize(count); + if (!result) + { + return result; + } + + // + double value = -1; + for (int i = 0; i < count; i++) + { + // + ENUM_X_CYCLES iCycle = cycles[i]; + + // + double iValue = -1; + switch (iCycle) + { + // + case X_CYCLE_TRIGGER: + iValue = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + break; + + // + case X_CYCLE_DECISION: + iValue = conditions.decisionConditions.x121Conditions.valesBuffer[0]; + break; + + // + case X_CYCLE_ANALYSE: + iValue = conditions.analyseConditions.x121Conditions.valesBuffer[0]; + break; + + // + case X_CYCLE_VERIFICATION: + iValue = conditions.verificationConditions.x121Conditions.valesBuffer[0]; + break; + + // + case X_CYCLE_CONSOLIDATION: + iValue = conditions.consolidationConditions.x121Conditions.valesBuffer[0]; + break; + + // + case X_CYCLE_VISION: + iValue = conditions.visionConditions.x121Conditions.valesBuffer[0]; + break; + } + + // + if (iValue > 0) + { + // + if (value <= 0) + { + value = iValue; + } + + // + result = value == iValue; + if (!result) + { + break; + } + } + } + + // + return result; + } + + /** + * Detect Sar State for Signalling ... + * + * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... + * @param dir: ENUM_X_DIRECTION member Reference ... + * @param conditions: X121SMCStrategyConditions instance, Reference ... + * + * @return ( bool ) + */ + bool DetectSarState( + ENUM_X_121_SMC_PROVIDERS forProvider, + ENUM_X_DIRECTION &dir, + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + dir = X_DIRECTION_NONE; + + // + bool isBullish = false; + bool isBearish = false; + + // + if (forProvider == X_121_SMC_PROVIDER_SMPV) + { + // + isBullish = + // + // Check One of Verification or Consolidation Cycles Must be Sar Bullish ... + (conditions.verificationConditions.x121Conditions.isSarBullish || + conditions.consolidationConditions.x121Conditions.isSarBullish) + // + && + // + // Decision and Analyse Cycles Must be Bullish ... + (conditions.decisionConditions.x121Conditions.isSarBullish && + conditions.analyseConditions.x121Conditions.isSarBullish) + // + && + // + // Trigger State Must be Bearish ... + conditions.triggerConditions.x121Conditions.isSarBearish + // + ; + + // + isBearish = + // + // Check One of Verification or Consolidation Cycles Must be Sar Bearish ... + (conditions.verificationConditions.x121Conditions.isSarBearish || + conditions.consolidationConditions.x121Conditions.isSarBearish) + // + && + // + // Decision and Analyse Cycles Must be Bearish ... + (conditions.decisionConditions.x121Conditions.isSarBearish && + conditions.analyseConditions.x121Conditions.isSarBearish) + // + && + // + // Trigger State Must be Bullish ... + conditions.triggerConditions.x121Conditions.isSarBullish + // + ; + } + + // + if (forProvider == X_121_SMC_PROVIDER_RJBPV) + { + // + isBullish = + // + // Trigger, Decision and Analyse must be Directional ... + conditions.triggerConditions.x121Conditions.isSarBullish && + conditions.decisionConditions.x121Conditions.isSarBullish && + conditions.analyseConditions.x121Conditions.isSarBullish + // + ; + + // + isBearish = + // + // Trigger, Decision and Analyse must be Directional ... + conditions.triggerConditions.x121Conditions.isSarBearish && + conditions.decisionConditions.x121Conditions.isSarBearish && + conditions.analyseConditions.x121Conditions.isSarBearish + // + ; + } + + // + if (forProvider == X_121_SMC_PROVIDER_VWAPC) + { + // + isBullish = + // + // All Cycles Sars Must be Directional exept Vision ... + conditions.triggerConditions.x121Conditions.isSarBullish && + conditions.decisionConditions.x121Conditions.isSarBullish && + conditions.analyseConditions.x121Conditions.isSarBullish && + conditions.verificationConditions.x121Conditions.isSarBullish && + conditions.consolidationConditions.x121Conditions.isSarBullish + // + ; + + // + isBearish = + // + // All Cycles Sars Must be Directional exept Vision ... + conditions.triggerConditions.x121Conditions.isSarBearish && + conditions.decisionConditions.x121Conditions.isSarBearish && + conditions.analyseConditions.x121Conditions.isSarBearish && + conditions.verificationConditions.x121Conditions.isSarBearish && + conditions.consolidationConditions.x121Conditions.isSarBearish + // + ; + } + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + dir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + return result; + } + + /** + * Detect Sar State for Signalling ... + * + * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... + * @param dir: ENUM_X_DIRECTION member Reference ... + * @param conditions: X121SMCStrategyConditions instance, Reference ... + * + * @return ( bool ) + */ + bool DetectVWapState( + ENUM_X_121_SMC_PROVIDERS forProvider, + ENUM_X_DIRECTION &dir, + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + dir = X_DIRECTION_NONE; + + // + bool isBullish = false; + bool isBearish = false; + + // + if (forProvider == X_121_SMC_PROVIDER_SMPV) + { + // + isBullish = + // + // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ... + // + // Orders ... + (conditions.triggerConditions.x121Conditions.isVWapBullishOrdered && + conditions.decisionConditions.x121Conditions.isVWapBullishOrdered && + conditions.analyseConditions.x121Conditions.isVWapBullishOrdered) + // + && + // + // State ... + (conditions.triggerConditions.x121Conditions.isVWapBullishState && + conditions.decisionConditions.x121Conditions.isVWapBullishState && + conditions.analyseConditions.x121Conditions.isVWapBullishState) + // + && + // + // One of Verification and Consolidation must Be in Direction State ... + (conditions.verificationConditions.x121Conditions.isVWapBullishState || + conditions.consolidationConditions.x121Conditions.isVWapBullishState) + // + ; + + // + isBearish = + // + // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ... + // + // Orders ... + (conditions.triggerConditions.x121Conditions.isVWapBearishOrdered && + conditions.decisionConditions.x121Conditions.isVWapBearishOrdered && + conditions.analyseConditions.x121Conditions.isVWapBearishOrdered) + // + && + // + // State ... + (conditions.triggerConditions.x121Conditions.isVWapBearishState && + conditions.decisionConditions.x121Conditions.isVWapBearishState && + conditions.analyseConditions.x121Conditions.isVWapBearishState) + // + && + // + // One of Verification and Consolidation must Be in Direction State ... + (conditions.verificationConditions.x121Conditions.isVWapBearishState || + conditions.consolidationConditions.x121Conditions.isVWapBearishState) + // + ; + } + + // + if (forProvider == X_121_SMC_PROVIDER_VWAPC) + { + // + isBullish = + // + // All Cycles Must be State and Ordered Directional Except Vision ... + // State ... + conditions.triggerConditions.x121Conditions.isVWapBullishState && + conditions.decisionConditions.x121Conditions.isVWapBullishState && + conditions.analyseConditions.x121Conditions.isVWapBullishState && + conditions.verificationConditions.x121Conditions.isVWapBullishState && + conditions.consolidationConditions.x121Conditions.isVWapBullishState + // + && + // Order ... + conditions.triggerConditions.x121Conditions.isVWapBullishOrdered && + conditions.decisionConditions.x121Conditions.isVWapBullishOrdered && + conditions.analyseConditions.x121Conditions.isVWapBullishOrdered && + conditions.verificationConditions.x121Conditions.isVWapBullishOrdered && + conditions.consolidationConditions.x121Conditions.isVWapBullishOrdered + // + ; + + // + isBearish = + // + // All Cycles Must be State and Ordered Directional Except Vision ... + // State ... + conditions.triggerConditions.x121Conditions.isVWapBearishState && + conditions.decisionConditions.x121Conditions.isVWapBearishState && + conditions.analyseConditions.x121Conditions.isVWapBearishState && + conditions.verificationConditions.x121Conditions.isVWapBearishState && + conditions.consolidationConditions.x121Conditions.isVWapBearishState + // + && + // Order ... + conditions.triggerConditions.x121Conditions.isVWapBearishOrdered && + conditions.decisionConditions.x121Conditions.isVWapBearishOrdered && + conditions.analyseConditions.x121Conditions.isVWapBearishOrdered && + conditions.verificationConditions.x121Conditions.isVWapBearishOrdered && + conditions.consolidationConditions.x121Conditions.isVWapBearishOrdered + // + ; + } + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + dir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + return result; + } + + /** + * Detect Candlestic Patters for Signalling ... + * + * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... + * @param dir: ENUM_X_DIRECTION member Reference ... + * @param conditions: X121SMCStrategyConditions instance, Reference ... + * + * @return ( bool ) + */ + bool DetectCandlestic( + ENUM_X_121_SMC_PROVIDERS forProvider, + ENUM_X_DIRECTION &dir, + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + dir = X_DIRECTION_NONE; + + // + int cIndex = 1; + int pIndex = cIndex + 1; + + // + // Select Specified Cycle Helper ... + XC121SMCCycleHelper *cycleHelper = mTriggerCycleHelper; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = cycleHelper.GetPeriod(); + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + // Momentum Bar ... + ENUM_X_DIRECTION cBarMomentumDir; + bool isCBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar( + cBar, + cBarMomentumDir // + ); + + // + // Rejection Bar ... + ENUM_X_DIRECTION cBarRejectionDir; + bool isCBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar( + cBar, + cBarRejectionDir // + ); + + // + // Engulf Bar ... + ENUM_X_DIRECTION cBarEngulfDir; + bool isCBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar( + cBar, + cBarEngulfDir // + ); + + // + // Pin Bar ... + ENUM_X_DIRECTION cBarPinDir; + bool isCBarPin = cycleHelper.mBarAnalyser.IsPinBar( + cBar, + cBarPinDir // + ); + + // + XOHCL pBar; + result = pBar.Init( + symbol, + period, + pIndex // + ); + if (!result) + { + return result; + } + + // + // Momentum Bar ... + ENUM_X_DIRECTION pBarMomentumDir; + bool isPBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar( + pBar, + pBarMomentumDir // + ); + + // + // Rejection Bar ... + ENUM_X_DIRECTION pBarRejectionDir; + bool isPBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar( + pBar, + pBarRejectionDir // + ); + + // + // Engulf Bar ... + ENUM_X_DIRECTION pBarEngulfDir; + bool isPBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar( + pBar, + pBarEngulfDir // + ); + + // + // Pin Bar ... + ENUM_X_DIRECTION pBarPinDir; + bool isPBarPin = cycleHelper.mBarAnalyser.IsPinBar( + pBar, + pBarPinDir // + ); + + // + bool isBullish = false; + bool isBearish = false; + + // + if (forProvider == X_121_SMC_PROVIDER_VWAPC) + { + // + isBullish = + // + // pBar is Pin and cBar is Momentum or Rejection or Engulf + ( + // + (isPBarPin && + IsBullish(pBarPinDir) && + ( + // + (isCBarMomentum && + IsBullish(cBarMomentumDir)) + // + || + // + (isCBarRejection && + IsBullish(cBarRejectionDir)) + // + || + // + (isCBarEngulf && + IsBullish(cBarEngulfDir)) + // + ) + // + ) + // + || + // + // pBar is Engulf and cBar is Momentum or Rejection or Pin ... + (isPBarEngulf && + IsBullish(pBarEngulfDir) && + ( + // + (isCBarMomentum && + IsBullish(cBarMomentumDir)) + // + || + // + (isCBarRejection && + IsBullish(cBarRejectionDir)) + // + || + // + (isCBarPin && + IsBullish(cBarPinDir)) + // + ) + // + ) + // + || + // + // pBar is Rejection and cBar is Momentum or Engulf or Pin ... + (isPBarRejection && + IsBullish(pBarRejectionDir) && + ( + // + (isCBarMomentum && + IsBullish(cBarMomentumDir)) + // + || + // + (isCBarEngulf && + IsBullish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBullish(cBarPinDir)) + // + ) + // + ) + // + || + // + // pBar is Momentum and cBar is Rejection or Engulf or Pin ... + (isPBarMomentum && + IsBullish(pBarMomentumDir) && + ( + // + (isCBarRejection && + IsBullish(cBarRejectionDir)) + // + || + // + (isCBarEngulf && + IsBullish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBullish(cBarPinDir)) + // + ) + // + ) + // + || + // + // cBar is Pin and Momentum and Rejection and Engulf ... + ( + // + (isCBarPin && + IsBullish(cBarPinDir)) + // + && + // + (isCBarMomentum && + IsBullish(cBarMomentumDir)) + // + && + // + (isCBarRejection && + IsBullish(cBarRejectionDir)) + // + && + // + (isCBarEngulf && + IsBullish(cBarEngulfDir)) + // + ) + // + ) + // + ; + + // + isBearish = + // + // pBar is Pin and cBar is Momentum or Rejection or Engulf + ( + // + (isPBarPin && + IsBearish(pBarPinDir) && + ( + // + (isCBarMomentum && + IsBearish(cBarMomentumDir)) + // + || + // + (isCBarRejection && + IsBearish(cBarRejectionDir)) + // + || + // + (isCBarEngulf && + IsBearish(cBarEngulfDir)) + // + ) + // + ) + // + || + // + // pBar is Engulf and cBar is Momentum or Rejection or Pin ... + (isPBarEngulf && + IsBearish(pBarEngulfDir) && + ( + // + (isCBarMomentum && + IsBearish(cBarMomentumDir)) + // + || + // + (isCBarRejection && + IsBearish(cBarRejectionDir)) + // + || + // + (isCBarPin && + IsBearish(cBarPinDir)) + // + ) + // + ) + // + || + // + // pBar is Rejection and cBar is Momentum or Engulf or Pin ... + (isPBarRejection && + IsBearish(pBarRejectionDir) && + ( + // + (isCBarMomentum && + IsBearish(cBarMomentumDir)) + // + || + // + (isCBarEngulf && + IsBearish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBearish(cBarPinDir)) + // + ) + // + ) + // + || + // + // pBar is Momentum and cBar is Rejection or Engulf or Pin ... + (isPBarMomentum && + IsBearish(pBarMomentumDir) && + ( + // + (isCBarRejection && + IsBearish(cBarRejectionDir)) + // + || + // + (isCBarEngulf && + IsBearish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBearish(cBarPinDir)) + // + ) + // + ) + // + || + // + // cBar is Pin and Momentum and Rejection and Engulf ... + ( + // + (isCBarPin && + IsBearish(cBarPinDir)) + // + && + // + (isCBarMomentum && + IsBearish(cBarMomentumDir)) + // + && + // + (isCBarRejection && + IsBearish(cBarRejectionDir)) + // + && + // + (isCBarEngulf && + IsBearish(cBarEngulfDir)) + // + ) + // + ) + // + ; + } + + // + if (forProvider == X_121_SMC_PROVIDER_RJBPV) + { + // + isBullish = + // + // CBar is Pin, Engulf, Momentum or Rejection ... + ( + // // + // (isCBarMomentum && + // IsBullish(cBarMomentumDir)) + // // + // || + // // + (isCBarRejection && + IsBullish(cBarRejectionDir)) + // // + // || + // // + // (isCBarEngulf && + // IsBullish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBullish(cBarPinDir)) + // + ) + // + ; + + // + isBearish = + // + // CBar is Pin, Engulf, Momentum or Rejection ... + ( + // + // (isCBarMomentum && + // IsBearish(cBarMomentumDir)) + // // + // || + // // + (isCBarRejection && + IsBearish(cBarRejectionDir)) + // // + // || + // // + // (isCBarEngulf && + // IsBearish(cBarEngulfDir)) + // + || + // + (isCBarPin && + IsBearish(cBarPinDir)) + // + ) + // + ; + } + + // + result = isBullish || + isBearish; + if (!result) + { + return result; + } + + // + dir = + isBullish + ? X_DIRECTION_BULLISH + : X_DIRECTION_BEARISH; + + // + return result; + } + +//////////////////////////////////////////////////////////////////////////////////// + + // + // TODO: Remove this ... + XSMCStrategySetupConditions mTestConditions; + bool DetectTestSignal( + X121SMCStrategyConditions &conditions // + ) + { + // + bool result = false; + + // + string symbol = GetSymbol(); + ENUM_TIMEFRAMES period = GetPeriod(); + + // + ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; + string providerStr = ToString(provider); + + // + int zIndex = 0; + int cIndex = zIndex + 1; + int pIndex = cIndex + 1; + int ppIndex = pIndex + 1; + + // + XOHCL zBar; + result = zBar.Init( + symbol, + period, + zIndex // + ); + if (!result) + { + return result; + } + + // + XOHCL cBar; + result = cBar.Init( + symbol, + period, + cIndex // + ); + if (!result) + { + return result; + } + + // + bool isBullish = false; + bool isBearish = false; + + // + double ask = GetAsk(symbol); + double bid = GetBid(symbol); + datetime cTime = TimeCurrent(); + + // + double ll = cBar.FindLowest(9, MODE_LOW); + double hh = cBar.FindHighest(9, MODE_HIGH); + + // + double selectedSL = 0; + + // + // Retrieve Peak and Vale ... + double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + + // + X121SMCCycleConditions triggerConditions = conditions.triggerConditions; + X121SMCCycleConditions decisionConditions = conditions.decisionConditions; + X121SMCCycleConditions analyseConditions = conditions.analyseConditions; + X121SMCCycleConditions verificationConditions = conditions.verificationConditions; + X121SMCCycleConditions consolidationConditions = conditions.consolidationConditions; + X121SMCCycleConditions visionConditions = conditions.visionConditions; + + // + XPOIState triggerState = triggerConditions.state; + XPOIState decisionState = decisionConditions.state; + XPOIState analyseState = analyseConditions.state; + XPOIState verificationState = verificationConditions.state; + XPOIState consolidationState = consolidationConditions.state; + XPOIState visionState = visionConditions.state; + + // + int zoneValidationDivider = 10; + int validPivotRepetition = mTriggerCycleHelper.mX121Helper + .GetDonChainLength(); + + // + // Waits For Bullish Or Bearish Order Block Forms ... + bool hasBullishOB = mTestConditions.HasBullishOrderBlock(); + bool hasBearishOB = mTestConditions.HasBearishOrderBlock(); + result = mTestConditions.HasOrderBlock(); + if (!result) + { + // + // Try to Detect Order Blocks ... + XPOIState state = consolidationState; + + // + // Bullish ... + if (!hasBullishOB) + { + // + // Bullish ... + int bullishOBsCount = state.CountBullishOrderBlocks(); + if (IsValidSize(bullishOBsCount)) + { + // + XCFVG *fvg = NULL; + XCOrderBlock *ob = NULL; + XCOrderBlock *bullishOBs[]; + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = state.bullishOrderBlocks[i]; + + // + bool isValid = cBar.low > iZone.Upper() && + HasValidBullishFVG( + analyseState, + iZone, + fvg, + cBar // + ); + if (isValid) + { + // + Add( + iZone, + bullishOBs // + ); + } + } + + // + bullishOBsCount = ArraySize(bullishOBs); + if (IsValidSize(bullishOBsCount)) + { + // + for (int i = 0; i < bullishOBsCount; i++) + { + // + XCOrderBlock *iZone = bullishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Upper() < iZone.Upper(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if ( + ob != NULL && + fvg != NULL && + ob.IsValid() && + fvg.IsValid()) + { + // + mTestConditions.bullishFVG = fvg; + mTestConditions.bullishFVGTime = cTime; + mTestConditions.bullishOrderBlock = ob; + mTestConditions.bullishOrderBlockTime = cTime; + } + } + } + + // + // Bearish ... + if (!hasBearishOB) + { + // + // Bearish ... + int bearishOBsCount = state.CountBearishOrderBlocks(); + if (IsValidSize(bearishOBsCount)) + { + // + XCFVG *fvg = NULL; + XCOrderBlock *ob = NULL; + XCOrderBlock *bearishOBs[]; + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = state.bearishOrderBlocks[i]; + + // + bool isValid = cBar.high < iZone.Lower() && + HasValidBearishFVG( + analyseState, + iZone, + fvg, + cBar // + ); + if (isValid) + { + // + Add( + iZone, + bearishOBs // + ); + } + } + + // + bearishOBsCount = ArraySize(bearishOBs); + if (IsValidSize(bearishOBsCount)) + { + // + for (int i = 0; i < bearishOBsCount; i++) + { + // + XCOrderBlock *iZone = bearishOBs[i]; + + // + bool isValid = ob == NULL + ? true + : ob.Lower() > iZone.Lower(); + if (isValid) + { + ob = iZone; + } + } + } + + // + if ( + ob != NULL && + fvg != NULL && + ob.IsValid() && + fvg.IsValid()) + { + // + mTestConditions.bearishFVG = fvg; + mTestConditions.bearishFVGTime = cTime; + mTestConditions.bearishOrderBlock = ob; + mTestConditions.bearishOrderBlockTime = cTime; + } + } + } + + // + hasBullishOB = mTestConditions.HasBullishOrderBlock(); + hasBearishOB = mTestConditions.HasBearishOrderBlock(); + result = mTestConditions.HasOrderBlock(); + if (!result) + { + return result; + } + } + + // + // Renew and Draw Order Blocks ... + + // + if (hasBullishOB) + { + // + mTestConditions.bullishFVG.To(cTime); + mTestConditions.bullishOrderBlock.To(cTime); + + // + XCBullishOrderBlockObject *iOBObj; + bool isCreated = mPOIDrawer.CreateBullishOrderBlock( + mTestConditions.bullishOrderBlock, + iOBObj // + ); + if (isCreated) + { + // + iOBObj.ZoneWidth(4); + iOBObj.ZoneColor(clrAqua); + + // + AddObjectIfNotExists(iOBObj); + } + + // + XCBullishFairValueGapObject *iFVGObj; + isCreated = mPOIDrawer.CreateBullishFairValueGap( + mTestConditions.bullishFVG, + iFVGObj // + ); + if (isCreated) + { + // + iFVGObj.ZoneWidth(4); + + // + AddObjectIfNotExists(iFVGObj); + } + } + + // + if (hasBearishOB) + { + // + mTestConditions.bearishFVG.To(cTime); + mTestConditions.bearishOrderBlock.To(cTime); + + // + XCBearishOrderBlockObject *iObj; + bool isCreated = mPOIDrawer.CreateBearishOrderBlock( + mTestConditions.bearishOrderBlock, + iObj // + ); + if (isCreated) + { + // + iObj.ZoneWidth(4); + iObj.ZoneColor(clrMagenta); + + // + AddObjectIfNotExists(iObj); + } + + // + XCBearishFairValueGapObject *iFVGObj; + isCreated = mPOIDrawer.CreateBearishFairValueGap( + mTestConditions.bearishFVG, + iFVGObj // + ); + if (isCreated) + { + // + iFVGObj.ZoneWidth(4); + + // + AddObjectIfNotExists(iFVGObj); + } + } + + // + // Here we Make Sure we Have Valid Order Blocks ... + // we have to Validate Order Block Attacks ... + bool isBullishOBAttacked = mTestConditions.isBullishOrderBlockAttacked; + bool isBearishOBAttacked = mTestConditions.isBearishOrderBlockAttacked; + result = mTestConditions.IsOrderBlockAttacked(); + if (!result) + { + // + // Detect Order Blocks Attack ... + + // + // Bullish Order Block ... + XCOrderBlock *bullishOb = mTestConditions.bullishOrderBlock; + isBullishOBAttacked = + // + bullishOb.IsValid() && + cBar.high <= bullishOb.Upper() && + cBar.low >= bullishOb.Lower() + // + ; + if (!isBullishOBAttacked) + { + // + // Try to Reset Bullish Ob if Needed ... + int timePassed = (int)cTime - (int)mTestConditions.bullishOrderBlockTime; + int barsPassed = timePassed / PeriodSeconds(period); + bool canReset = barsPassed >= validPivotRepetition * 10; + if (canReset) + { + // + ClearDraws(); + mTestConditions.ResetBullishOrderBlock(); + } + } + + // + // Bearish Order Block ... + XCOrderBlock *bearishOb = mTestConditions.bearishOrderBlock; + isBearishOBAttacked = + // + bearishOb.IsValid() && + cBar.high <= bearishOb.Upper() && + cBar.low >= bearishOb.Lower() + // + ; + if (!isBearishOBAttacked) + { + // + // Try to Reset Bullish Ob if Needed ... + int timePassed = (int)cTime - (int)mTestConditions.bearishOrderBlockTime; + int barsPassed = timePassed / PeriodSeconds(period); + bool canReset = barsPassed >= validPivotRepetition * 10; + if (canReset) + { + // + ClearDraws(); + mTestConditions.ResetBearishOrderBlock(); + } + } + + // + bool isOrderBlockAttacked = isBullishOBAttacked || + isBearishOBAttacked; + if (isOrderBlockAttacked) + { + // + if (isBullishOBAttacked) + { + mTestConditions.isBullishOrderBlockAttacked = isBullishOBAttacked; + } + + // + if (isBearishOBAttacked) + { + mTestConditions.isBearishOrderBlockAttacked = isBearishOBAttacked; + } + } + + // + result = mTestConditions.IsOrderBlockAttacked(); + if (!result) + { + return result; + } + } + + // + // Detect Analyse State FVG ... + + // + // here We Make Sure Order Block is ttacked Before ... + // Loockup For Zone Break ... + bool isBullishOrderBlockBreaked = false; + bool isBearishOrderBlockBreaked = false; + if (isBullishOBAttacked) + { + // + isBullishOrderBlockBreaked = + // + mTestConditions.HasBullishOrderBlock() + // + && + // + ( + // + // Break From Bottom to Top ... + (ll < mTestConditions.bullishOrderBlock.Upper() && + hh > mTestConditions.bullishOrderBlock.Upper()) + // + || + // + // Break From Top to Bottom ... + (hh > mTestConditions.bullishOrderBlock.Lower() && + ll < mTestConditions.bullishOrderBlock.Lower()) + // + ) + // + ; + } + if (isBearishOBAttacked) + { + // + isBearishOrderBlockBreaked = + // + mTestConditions.HasBearishOrderBlock() + // + && + // + ( + // + // Break From Bottom to Top ... + (ll < mTestConditions.bearishOrderBlock.Upper() && + hh > mTestConditions.bearishOrderBlock.Upper()) + // + || + // + // Break From Top to Bottom ... + (hh > mTestConditions.bearishOrderBlock.Lower() && + ll < mTestConditions.bearishOrderBlock.Lower()) + // + ) + // + ; + } + + // + bool isOrderBlockBreaked = isBullishOrderBlockBreaked || + isBearishOrderBlockBreaked; + if (isOrderBlockBreaked) + { + // + // Clean Order Block ... + + // + if (isBullishOrderBlockBreaked) + { + // + ClearDraws(); + mTestConditions.ResetBullishOrderBlock(); + } + + // + if (isBearishOrderBlockBreaked) + { + // + ClearDraws(); + mTestConditions.ResetBearishOrderBlock(); + } + } + result = !isOrderBlockBreaked; + if (!result) + { + return result; + } + + // + // Try to Getting Setup Conditions ... + + // + // Check Setting Upped ... + result = mTestConditions.IsSetuped(); + if (!result) + { + return result; + } + + // + // Try To Detect Trigger Conditions ... + + // + // Check Conditions is Prepared for Trigger ... + result = mTestConditions.CanTrigger(); + if (!result) + { + return result; + } + + // + // Issues Signal on Conditions ... + conditions.signalDir = mTestConditions.dir; + conditions.provider = providerStr; + conditions.sl = mTestConditions.sl; + + // + mTestConditions.Clean(); + + // + return result; + } + + // + // Helper Functions ... + + /** + * Detect Valid Order Block's FVG ... + * + * @return ( bool ) + */ + bool HasValidBullishFVG( + XPOIState &state, + XCOrderBlock *ob, + XCFVG *&fvg, + XOHCL &bar // + ) + { + // + bool result = false; + + // + fvg = NULL; + + // + // Validate ... + result = + // + ob != NULL && + bar.IsValid() && + state.IsValid() && + ob.IsBullish() && + state.HasChild() + // + ; + if (!result) + { + return result; + } + + // + // Counting FVGs ... + int count = state.CountBullishFairValueGaps(); + result = IsValidSize(count); + if (!result) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + XCFVG *iFVG = state.bullishFairValueGaps[i]; + + // + bool isValid = + // + // Must be Happens After Order Block ... + iFVG.From() > ob.From() + // + && + // + // Must Happens Inside or Boundary of Order Blocks ... + iFVG.Lower() > ob.Lower() && + iFVG.Lower() < ob.Upper() + // + // && + // + // Must Not Touched till bar ... + // + ; + if (isValid) + { + // + bool canSet = fvg == NULL; + if (canSet) + { + // + fvg = iFVG; + break; + } + } + } + + // + return result; + } + + /** + * Detect Valid Order Block's FVG ... + * + * @return ( bool ) + */ + bool HasValidBearishFVG( + XPOIState &state, + XCOrderBlock *ob, + XCFVG *&fvg, + XOHCL &bar // + ) + { + // + bool result = false; + + // + fvg = NULL; + + // + // Validate ... + result = + // + ob != NULL && + bar.IsValid() && + state.IsValid() && + ob.IsBearish() && + state.HasChild() + // + ; + if (!result) + { + return result; + } + + // + // Counting FVGs ... + int count = state.CountBearishFairValueGaps(); + result = IsValidSize(count); + if (!result) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + XCFVG *iFVG = state.bearishFairValueGaps[i]; + + // + bool isValid = + // + // Must be Happens After Order Block ... + iFVG.From() > ob.From() + // + && + // + // Must Happens Inside or Boundary of Order Blocks ... + iFVG.Upper() < ob.Upper() && + iFVG.Upper() > ob.Lower() + // + // && + // + // Must Not Touched till bar ... + // + ; + if (isValid) + { + // + bool canSet = fvg == NULL; + if (canSet) + { + // + fvg = iFVG; + break; + } + } + } + + // + return result; + } + +struct XSMCStrategySetupConditions +{ + // + // Props ... + + // + string symbol; + ENUM_TIMEFRAMES period; + + // + double sl; + ENUM_X_DIRECTION dir; + ENUM_X_POSITION_TYPES type; + + // + // Setup Props ... + + // + datetime setupTime; + datetime triggerTime; + + // + datetime bullishOrderBlockTime; + XCOrderBlock *bullishOrderBlock; + bool isBullishOrderBlockAttacked; + + // + datetime bearishOrderBlockTime; + XCOrderBlock *bearishOrderBlock; + bool isBearishOrderBlockAttacked; + + // + datetime bullishFVGTime; + XCFVG *bullishFVG; + bool isBullishFVGRejected; + + // + datetime bearishFVGTime; + XCFVG *bearishFVG; + bool isBearishFVGRejected; + + // + XPVPivotPoint validPeak; + XPVPivotPoint validVale; + + // + // Trigger Props ... + + // + // Constructor ... + XSMCStrategySetupConditions() + { + Clean(); + } + + // + // Tools ... + + /** + * Cleaning Up ... + */ + void Clean() + { + // + sl = 0; + + // + dir = X_DIRECTION_NONE; + type = X_POSITION_TYPE_NONE; + + // + symbol = NULL; + period = NULL; + setupTime = NULL; + triggerTime = NULL; + + // + validPeak.Clean(); + validVale.Clean(); + + // + bullishOrderBlock = NULL; + bearishOrderBlock = NULL; + bullishOrderBlockTime = NULL; + bearishOrderBlockTime = NULL; + + // + bullishFVG = NULL; + bullishFVGTime = NULL; + isBullishFVGRejected = false; + + // + bearishFVG = NULL; + bearishFVGTime = NULL; + isBearishFVGRejected = false; + + // + isBullishOrderBlockAttacked = false; + isBearishOrderBlockAttacked = false; + } + + /** + * 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; + } + + /** + * 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; + } + + // + // Helpers ... + + // + // Order Block ... + + /** + * Check has Order Block ... + * + * @return ( bool ) + */ + bool HasOrderBlock() + { + // + bool result = false; + + // + result = HasBullishOrderBlock() && + HasBearishOrderBlock(); + + // + return result; + } + + bool HasBullishOrderBlock() + { + // + bool result = false; + + // + result = + // + (bullishOrderBlock != NULL && + bullishOrderBlock.IsValid()) + // + ; + + // + return result; + } + + bool HasBearishOrderBlock() + { + // + bool result = false; + + // + result = + // + (bearishOrderBlock != NULL && + bearishOrderBlock.IsValid()) + // + ; + + // + return result; + } + + bool IsOrderBlockAttacked() + { + // + bool result = isBullishOrderBlockAttacked || + isBearishOrderBlockAttacked; + + // + return result; + } + + void ResetBullishOrderBlock() + { + // + bullishOrderBlock = NULL; + bullishOrderBlockTime = NULL; + isBullishOrderBlockAttacked = false; + } + + void ResetBearishOrderBlock() + { + // + bearishOrderBlock = NULL; + bearishOrderBlockTime = NULL; + isBearishOrderBlockAttacked = false; + } + + bool HasFVG() + { + // + bool result = false; + + // + result = HasBullishFVG() || + HasBearishFVG(); + + // + return result; + } + + bool HasBullishFVG() + { + // + bool result = false; + + // + result = IsValid(bullishFVGTime) && + bullishFVG != NULL && + bullishFVG.IsValid(); + + // + return result; + } + + bool HasBearishFVG() + { + // + bool result = false; + + // + result = IsValid(bearishFVGTime) && + bearishFVG != NULL && + bearishFVG.IsValid(); + + // + return result; + } + + // +}; + +////////////////////////////////////////////////////////////////////////////////// + diff --git a/Libraries/x-saherelm.common.lib.mq5 b/Libraries/x-saherelm.common.lib.mq5 index 3d02a126..10d9006e 100644 --- a/Libraries/x-saherelm.common.lib.mq5 +++ b/Libraries/x-saherelm.common.lib.mq5 @@ -44,12 +44,38 @@ enum ENUM_X_PRICE // enum ENUM_X_DIRECTION { - X_DIRECTION_ALL, - X_DIRECTION_NONE, - X_DIRECTION_BULLISH, - X_DIRECTION_BEARISH, + X_DIRECTION_ALL, // All + X_DIRECTION_NONE, // None + X_DIRECTION_BULLISH, // Bullish + X_DIRECTION_BEARISH, // Bearish }; +string ToString(ENUM_X_DIRECTION value) +{ + // + string result = NULL; + + // + switch (value) + { + case X_DIRECTION_ALL: + result = "ALL"; + break; + case X_DIRECTION_NONE: + result = "NONE"; + break; + case X_DIRECTION_BULLISH: + result = "BULLISH"; + break; + case X_DIRECTION_BEARISH: + result = "BEARISH"; + break; + } + + // + return result; +} + // // Swing Types Enum ... enum ENUM_X_SWING_TYPE @@ -8571,7 +8597,8 @@ int FillPrice( _mLoopback, open // ); - if (!IsValidSize(result)) { + if (!IsValidSize(result)) + { return result; } @@ -8584,7 +8611,8 @@ int FillPrice( _mLoopback, high // ); - if (!IsValidSize(result)) { + if (!IsValidSize(result)) + { return result; } @@ -8597,7 +8625,8 @@ int FillPrice( _mLoopback, low // ); - if (!IsValidSize(result)) { + if (!IsValidSize(result)) + { return result; } @@ -8610,7 +8639,8 @@ int FillPrice( _mLoopback, close // ); - if (!IsValidSize(result)) { + if (!IsValidSize(result)) + { return result; } diff --git a/Libraries/x-saherelm.x-poi.lib.mq5 b/Libraries/x-saherelm.x-poi.lib.mq5 index f3f37546..ec33922a 100644 --- a/Libraries/x-saherelm.x-poi.lib.mq5 +++ b/Libraries/x-saherelm.x-poi.lib.mq5 @@ -3725,6 +3725,7 @@ struct XConsolidationZone double lower; // Lower ... // + datetime initTime; int loopback; // Loopback ... // @@ -3775,6 +3776,10 @@ struct XConsolidationZone _loopback > 0 // ; + if (!result) + { + return result; + } // upper = _upper; @@ -3785,22 +3790,87 @@ struct XConsolidationZone // result = IsValid(); + if (result) + { + initTime = TimeCurrent(); + } // return result; } + /** + * Update Breaked State ... + */ + void Update() + { + // + if (!IsValid()) + { + return; + } + + // + if (IsBreaked()) + { + return; + } + + // + XOHCL cBar; + bool isInited = cBar.Init( + symbol, + period, + 0 // + ); + if (!isInited) + { + return; + } + + // + XOHCL pBar; + isInited = cBar.GetPreviousBar(pBar); + if (!isInited) + { + return; + } + + // + // Check Consolidation Breaks ... + // Update Zone ... + // Add it ... + bool isBOSTop = cBar.high > upper; + bool isBOSBottom = cBar.low < lower; + bool hasBOS = isBOSTop || + isBOSBottom; + if (!hasBOS) + { + return; + } + + // + // Calculate Break Direction ... + breakerBar = cBar; + breakDirection = isBOSTop + ? X_DIRECTION_BULLISH + : isBOSBottom + ? X_DIRECTION_BEARISH + : X_DIRECTION_NONE; + } + /** * Cleanup ... */ void Clean() { // - symbol = NULL; - period = NULL; upper = 0; lower = 0; loopback = 0; + symbol = NULL; + period = NULL; + initTime = NULL; breakerBar.Clean(); breakDirection = X_DIRECTION_NONE; } @@ -3966,6 +4036,62 @@ struct XConsolidationZone return result; } + /** + * Retrieve Start Time ... + * + * @return ( datetime ) + */ + datetime From() + { + // + datetime result = NULL; + + // + if (!IsValid()) + { + return result; + } + + // + int startIndex = iBarShift( + symbol, + period, + initTime // + ); + + // + result = iTime( + symbol, + period, + loopback + startIndex // + ); + + // + return result; + } + + /** + * Retrieve Unique Identifier ... + * + * @return ( string ) + */ + string GetTag() + { + // + string result = + // + GetTypeName(this) + "_" + + symbol + "_" + + ToString(period) + "_" + + ToString(upper) + "_" + + ToString(lower) + // + ; + + // + return result; + } + // }; diff --git a/MQL5.code-workspace b/MQL5.code-workspace index aecf3431..9ae992df 100644 --- a/MQL5.code-workspace +++ b/MQL5.code-workspace @@ -11,7 +11,8 @@ ], "C_Cpp.clang_format_style": "{ BasedOnStyle: Microsoft, UseTab: Never, IndentWidth: 4, TabWidth: 4, ColumnLimit: 0}", "files.associations": { - "*.mq5": "cpp" + "*.mq5": "cpp", + "*.mqh": "cpp" } } } diff --git a/X121SMCEA/Classes/x-121.smc.market.cycle.helper.class.mq5 b/X121SMCEA/Classes/x-121.smc.market.cycle.helper.class.mq5 index 107e43a4..a9c5f2d9 100644 --- a/X121SMCEA/Classes/x-121.smc.market.cycle.helper.class.mq5 +++ b/X121SMCEA/Classes/x-121.smc.market.cycle.helper.class.mq5 @@ -997,6 +997,145 @@ class XC121SMCCycleHelper : public XCBase return result; } + /** + * Count Pivot Points Change ... + * + * @return ( int ) + */ + int CountPivotPoints() + { + return ArraySize(mPivotPoints); + } + + /** + * Retrieve All Pivot Point Changes as a Collection ... + * + * @param pivots: XPVPivotPoint instance Reference ... + * + * @return ( int ) + */ + int FillPivotPointss(XPVPivotPoint &pivots[]) + { + // + int result = 0; + + // + Clean(pivots); + + // + int count = CountPivotPoints(); + if (!IsValidSize(pivots)) + { + return result; + } + + // + Copy( + mPivotPoints, + pivots // + ); + + // + result = ArraySize(pivots); + + // + return result; + } + + /** + * Retrieve All Peak Pivot Point Changes as a Collection ... + * + * @param pivots: XPVPivotPoint instance Reference ... + * + * @return ( int ) + */ + int FillPeakPivotPoints(XPVPivotPoint &pivots[]) + { + // + int result = 0; + + // + Clean(pivots); + + // + int count = CountPivotPoints(); + if (!IsValidSize(count)) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + XPVPivotPoint iPivot = mPivotPoints[i]; + + // + bool isValid = iPivot.IsPeak(); + if (isValid) + { + // + AddRef( + iPivot, + pivots // + ); + } + } + + // + result = ArraySize(pivots); + + // + return result; + } + + /** + * Retrieve All Vale Pivot Point Changes as a Collection ... + * + * @param pivots: XPVPivotPoint instance Reference ... + * + * @return ( int ) + */ + int FillValePivotPoints(XPVPivotPoint &pivots[]) + { + // + int result = 0; + + // + Clean(pivots); + + // + int count = CountPivotPoints(); + if (!IsValidSize(count)) + { + return result; + } + + // + for (int i = 0; i < count; i++) + { + // + XPVPivotPoint iPivot = mPivotPoints[i]; + + // + bool isValid = iPivot.IsVale(); + if (isValid) + { + // + AddRef( + iPivot, + pivots // + ); + } + } + + // + result = ArraySize(pivots); + + // + return result; + } + // // Virtuals ... @@ -1456,9 +1595,9 @@ class XC121SMCCycleHelper : public XCBase int count = 0; double value = 0; int repetition = 0; - int minRepetition = 40; ENUM_TIMEFRAMES period = GetPeriod(); int periodSeconds = PeriodSeconds(period); + int minRepetition = mX121Helper.GetDonChainLength(); ENUM_XPV_PIVOTS type = isNewPeak ? XPV_PEAK : XPV_VALE; @@ -1486,31 +1625,37 @@ class XC121SMCCycleHelper : public XCBase } // - value = prevChange.after; - int delayTime = ((int)lastChange.time - (int)prevChange.time); - repetition = delayTime / periodSeconds; - - // - bool isValidPivot = repetition >= minRepetition; - if (isValidPivot) + if (lastChange.IsValid() && + prevChange.IsValid()) { // - XPVPivotPoint pivotPoint; - pivotPoint.type = type; - pivotPoint.value = value; - pivotPoint.repetition = repetition; + value = prevChange.after; + int delayTime = ((int)lastChange.time - (int)prevChange.time); + repetition = delayTime / periodSeconds; // - AddRef( - pivotPoint, - mPivotPoints // - ); + bool isValidPivot = repetition >= minRepetition; + if (isValidPivot) + { + // + XPVPivotPoint pivotPoint; + pivotPoint.type = type; + pivotPoint.value = value; + pivotPoint.time = prevChange.time; + pivotPoint.repetition = repetition; - // - Add( - PIVOT_POINT_DETECTED, - events // - ); + // + AddRef( + pivotPoint, + mPivotPoints // + ); + + // + Add( + PIVOT_POINT_DETECTED, + events // + ); + } } } } diff --git a/X121SMCEA/Libraries/x-121.smc.lib.mq5 b/X121SMCEA/Libraries/x-121.smc.lib.mq5 index b1a101e5..684ce7b9 100644 --- a/X121SMCEA/Libraries/x-121.smc.lib.mq5 +++ b/X121SMCEA/Libraries/x-121.smc.lib.mq5 @@ -455,6 +455,7 @@ struct XPVPivotPoint // Props ... double value; int repetition; + datetime time; ENUM_XPV_PIVOTS type; // @@ -474,6 +475,7 @@ struct XPVPivotPoint { // value = 0; + time = NULL; repetition = 0; type = XPV_NONE; } @@ -492,6 +494,7 @@ struct XPVPivotPoint result = // value > 0 && + IsValid(time) && repetition > 0 && type != XPV_NONE // @@ -500,6 +503,44 @@ struct XPVPivotPoint // return result; } + + /** + * Check current Pivot Point is Peak or not ... + * + * @return ( bool ) + */ + bool IsPeak() + { + // + bool result = false; + + // + result = IsValid() && + type == XPV_PEAK; + + // + return result; + } + + /** + * Check current Pivot Point is Vale or not ... + * + * @return ( bool ) + */ + bool IsVale() + { + // + bool result = false; + + // + result = IsValid() && + type == XPV_VALE; + + // + return result; + } + + // }; // @@ -1967,7 +2008,7 @@ ENUM_X_121_SMC_PROVIDERS ParseProvider(string value) // // Custom Providers Conditions ... -struct XTestProiderConditions +struct XSMCStrategySetupConditions { // // Props ... @@ -1978,49 +2019,29 @@ struct XTestProiderConditions // double sl; + ENUM_X_DIRECTION dir; ENUM_X_POSITION_TYPES type; // // Setup Props ... // - bool isNewPeak; - bool isNewVale; - - // - bool hasVisionSupplyZone; - XCSupplyZone *visionSupplyZone; - - // - bool hasVisionDemandZone; - XCDemandZone *visionDemandZone; - - // - bool hasConsolidationSupportZone; - XCSupportZone *consolidationSupportZone; - - // - bool hasConsolidationResistanceZone; - XCResistanceZone *consolidationResistanceZone; + datetime setupTime; + datetime triggerTime; + XConsolidationZone zone; // double peak; double vale; - - // - bool hasSamePeaks; - bool hasSameVales; - - // - datetime setupTime; - datetime triggerTime; + XPVPivotPoint validPeak; + XPVPivotPoint validVale; // // Trigger Props ... // // Constructor ... - XTestProiderConditions() + XSMCStrategySetupConditions() { Clean(); } @@ -2035,31 +2056,23 @@ struct XTestProiderConditions { // sl = 0; - peak = 0; - vale = 0; - - // - isNewPeak = false; - isNewVale = false; - hasSamePeaks = false; - hasSameVales = false; - hasVisionSupplyZone = false; - hasVisionDemandZone = false; - hasConsolidationSupportZone = false; - hasConsolidationResistanceZone = false; // + zone.Clean(); + dir = X_DIRECTION_NONE; type = X_POSITION_TYPE_NONE; // symbol = NULL; period = NULL; - triggerTime = NULL; setupTime = NULL; - visionSupplyZone = NULL; - visionDemandZone = NULL; - consolidationSupportZone = NULL; - consolidationResistanceZone = NULL; + triggerTime = NULL; + + // + peak = 0; + vale = 0; + validPeak.Clean(); + validVale.Clean(); } /** @@ -2069,69 +2082,26 @@ struct XTestProiderConditions * * @return ( bool ) */ - bool IsSetuped( - ENUM_X_DIRECTION &dir // - ) + bool IsSetuped() { // bool result = false; // - dir = X_DIRECTION_NONE; - - // - result = IsValid(setupTime); + result = IsValid(setupTime) && + HasDirection(dir); if (!result) { return result; } - // - bool isBullish = - // - isNewVale && - hasSamePeaks && - hasSameVales && - hasVisionDemandZone && - visionDemandZone != NULL && - visionDemandZone.IsValid() - // - ; - - // - bool isBearish = - // - isNewPeak && - hasSamePeaks && - hasSameVales && - hasVisionSupplyZone && - visionSupplyZone != NULL && - visionSupplyZone.IsValid() - // - ; - - // - result = - isBullish || - isBearish; - if (!result) - { - return result; - } - - // - dir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - // return result; } /** * Detect How we Can Trigger Signal ... - * + * * @return ( bool ) */ bool CanTrigger() @@ -2155,6 +2125,27 @@ struct XTestProiderConditions return result; } + // + // Helpers ... + + void UpdateZone() + { + // + if (!zone.IsValid() || + !validPeak.IsValid() || + !validVale.IsValid()) + { + return; + } + + // + zone.upper = validPeak.value; + zone.lower = validVale.value; + + // + zone.Update(); + } + // }; diff --git a/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 b/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 index 7e3ee030..b1de02fc 100644 --- a/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 +++ b/X121SMCEA/Strategy/x-121.smc.test.strategy.class.mq5 @@ -481,809 +481,9 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy // // Signalling Functions ... - /** - * Detect and Parse Market Conditions for Signalling ... - * - * @param conditions: X121SMCStrategyConditions instance Reference ... - * - * @return ( bool ) - */ - bool DetectSamePeaksAndValesSignal( - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - string symbol = GetSymbol(); - ENUM_TIMEFRAMES period = GetPeriod(); - - // - ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_SMPV; - string providerStr = ToString(provider); - - // - int zIndex = 0; - int cIndex = zIndex + 1; - int pIndex = cIndex + 1; - int ppIndex = pIndex + 1; - - // - XOHCL zBar; - result = zBar.Init( - symbol, - period, - zIndex // - ); - if (!result) - { - return result; - } - - // - XOHCL cBar; - result = cBar.Init( - symbol, - period, - cIndex // - ); - if (!result) - { - return result; - } - - // - string msg = NULL; - - // - double bid = GetBid(symbol); - datetime cTime = TimeCurrent(); - - // - double selectedSL = 0; - - // - // Here We Select Cycles For Conditions Check ... - ENUM_X_CYCLES cycles[5] = { - X_CYCLE_TRIGGER, - X_CYCLE_DECISION, - X_CYCLE_ANALYSE, - X_CYCLE_VERIFICATION, - X_CYCLE_CONSOLIDATION // - }; - bool hasSamePeaks = DetectSamePeaks( - cycles, - conditions // - ); - bool hasSameVales = DetectSameVales( - cycles, - conditions // - ); - result = - hasSamePeaks || - hasSameVales; - if (!result) - { - return result; - } - - // - // Check Peaks And Vales Order ... - bool hasPeakBreak = false; - bool hasValeBreak = false; - - // - // Retrieve Last Sar Change ... - XOHCL cSarChangeBar; - XOHCL pSarChangeBar; - XValueChange cSarChange; // Current Sar Change (IsDirect) ... - XValueChange pSarChange; // Prev Sar Change (Direct) ... - XValueChange sarChanges[]; - int sarChangesCount = mTriggerCycleHelper - .FillSarChanges(sarChanges); - if (IsValidSize(sarChangesCount) && - sarChangesCount > 2) - { - // - cSarChange = sarChanges[sarChangesCount - 1]; - pSarChange = sarChanges[sarChangesCount - 2]; - - // - result = cSarChange.FillBar( - cSarChangeBar, - symbol, - period // - ); - if (!result) - { - return result; - } - - // - result = pSarChange.FillBar( - pSarChangeBar, - symbol, - period // - ); - if (!result) - { - return result; - } - - // - int start = cSarChangeBar.Index(); - int end = pSarChangeBar.Index(); - for (int i = start; i < end; i++) - { - // - ENUM_X_CYCLE_EVENTS iEvents[]; - X121SMCCycleConditions iConditions; - result = mTriggerCycleHelper.GetConditions( - iEvents, - iConditions, - i // - ); - if (!result) - { - continue; - } - - // - hasPeakBreak = - iConditions.x121Conditions.isNewPeakOverLast; - hasValeBreak = - iConditions.x121Conditions.isNewValeUnderLast; - result = hasPeakBreak || - hasValeBreak; - if (result) - { - break; - } - } - } - if (!result) - { - return result; - } - - // - // Check Sar State ... - ENUM_X_DIRECTION sarDir; - result = DetectSarState( - provider, - sarDir, - conditions // - ); - if (!result) - { - return result; - } - - // - // Check VWAP State ... - ENUM_X_DIRECTION vwapDir; - result = DetectVWapState( - provider, - vwapDir, - conditions // - ); - if (!result) - { - return result; - } - - // - // Detect a Valid Peaks Break ... - - // - // Find Supply and Demand Zones ... - // XPOIState state = conditions.visionConditions.state; - // int supplyZonesCount = - - // - bool isBullish = - // - hasSamePeaks && - hasPeakBreak && - IsBullish(sarDir) && - IsBullish(vwapDir) - // - ; - - // - bool isBearish = - // - hasSameVales && - hasValeBreak && - IsBearish(sarDir) && - IsBearish(vwapDir) - // - ; - - // - result = - isBullish || - isBearish; - if (!result) - { - return result; - } - - // - CustomStateDrawing( - conditions.visionConditions.state, - false, // - X_DIRECTION_NONE, - false, // ignoreSwingHighs - false, // ignoreSwingLows - true, // ignoreSupportZones - true, // ignoreResistanceZones - false, // ignoreSupplyZones - false, // ignoreDemandZones - true, // ignoreBullishOrderBlocks - true, // ignoreBearishOrderBlocks - true, // ignoreBullishFairValueGaps - true, // ignoreBearishFairValueGaps - true, // ignoreBullishRejectionBars - true, // ignoreBearishRejectionBars - true, // ignoreBullishMomentumBars - true // ignoreBearishMomentumBars - ); - - // - // Set SL, Provider and Direction ... - conditions.signalDir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - conditions.provider = providerStr; - - // - // Selectiong SL ... - double selectedSLRJ = SelectSL( - conditions, - conditions.signalDir, - X_121_SMC_SL_TYPE_REJECTION // - ); - double selectedSLMN = SelectSL( - conditions, - conditions.signalDir, - X_121_SMC_SL_TYPE_MOMENTUM // - ); - double selectedSLSW = SelectSL( - conditions, - conditions.signalDir, - X_121_SMC_SL_TYPE_SWING // - ); - double selectedSLSR = SelectSL( - conditions, - conditions.signalDir, - X_121_SMC_SL_TYPE_CURRENT_SAR // - ); - - // - double slCandidates[4] = { - selectedSLRJ, - selectedSLMN, - selectedSLSW, - selectedSLSR // - }; - selectedSL = isBullish - ? GetMin(slCandidates) - : GetMax(slCandidates); - - // - // Normalizing SL ... - double entry = GetEntry( - symbol, - conditions.signalDir // - ); - double pip = GetPipPrice(symbol); - double spread = GetSpread(symbol); - double points = GetPoints(symbol); - - // - if (isBullish && selectedSL <= entry) - { - selectedSL -= (points * 30) - spread; - } - else if (isBearish && selectedSL >= entry) - { - selectedSL += (points * 30) + spread; - } - - // - // Detect SL and TP ... - conditions.sl = selectedSL; - - // - return result; - } - - /** - * Detect and Parse Market Conditions for Signalling ... - * - * @param conditions: X121SMCStrategyConditions instance Reference ... - * - * @return ( bool ) - */ - bool DetectRJBPVSignal( - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - string symbol = GetSymbol(); - ENUM_TIMEFRAMES period = GetPeriod(); - - // - int zIndex = 0; - int cIndex = zIndex + 1; - int pIndex = cIndex + 1; - int ppIndex = pIndex + 1; - - // - 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; - } - - // - string msg = NULL; - - // - double bid = GetBid(symbol); - datetime cTime = TimeCurrent(); - - // - ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_RJBPV; - string providerStr = ToString(provider); - - // - // Bar High Eqauls to Peaks or Vale ... - double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[2]; - double vale = conditions.triggerConditions.x121Conditions.valesBuffer[2]; - bool isNewPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[2] != conditions.triggerConditions.x121Conditions.peaksBuffer[3]; - bool isNewVale = conditions.triggerConditions.x121Conditions.valesBuffer[2] != conditions.triggerConditions.x121Conditions.valesBuffer[3]; - bool isClosedUnderDonCloseUpper = cBar.close < - conditions.triggerConditions.x121Conditions.donCloseUpperBuffer[1]; - bool isClosedOverDonCloseLower = cBar.close > - conditions.triggerConditions.x121Conditions.donCloseLowerBuffer[1]; - bool isSarBullish = - zBar.low > conditions.triggerConditions.x121Conditions.sarBuffer[0]; - bool isSarBearish = - zBar.high < conditions.triggerConditions.x121Conditions.sarBuffer[0]; - - // - // XPVPivot orderFlow[]; - // ENUM_X_DIRECTION orderFlowDir; - // mTriggerCycleHelper - // .DetectOrderFlow( - // zIndex, - // orderFlow, - // orderFlowDir // - // ); - // int pivotsCount = ArraySize(orderFlow); - // result = IsValidSize(pivotsCount); - // if (!result) - // { - // return result; - // } - // XPVPivot lastPivot = orderFlow[pivotsCount - 1]; - - // - double zoneVerificationDivider = 10; - bool isPeakInsideSupplyZone = false; - bool isValeInsideDemandZone = false; - - // - XPOIState state = conditions.verificationConditions.state; - - // // - // // Detect Order Block ... - // XCOrderBlock *orderBlock = NULL; - - // // - // int bullishOBCount = state.CountBullishOrderBlocks(); - // if (IsValidSize(bullishOBCount)) - // { - // // - // for (int i = 0; i < bullishOBCount; i++) - // { - // // - // XCOrderBlock *iZone = state.bullishOrderBlocks[i]; - - // // - // bool isInside = vale >= iZone.Lower() && - // vale <= iZone.Upper() && - // bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); - // if (isInside) - // { - // // - // orderBlock = iZone; - // break; - // } - // } - // } - - // // - // int bearishOBCount = state.CountBearishOrderBlocks(); - // if (IsValidSize(bearishOBCount)) - // { - // // - // for (int i = 0; i < bearishOBCount; i++) - // { - // // - // XCOrderBlock *iZone = state.bearishOrderBlocks[i]; - - // // - // bool isInside = peak >= iZone.Lower() && - // peak <= iZone.Upper() && - // bid >= iZone.Upper() - ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); - // if (isInside) - // { - // // - // orderBlock = iZone; - // break; - // } - // } - // } - - // // - // result = orderBlock != NULL && - // orderBlock.IsValid(); - // if (!result) - // { - // return result; - // } - - // // - // // Draw Order Block ... - // orderBlock.To(TimeCurrent()); - // if (orderBlock.IsBullish()) - // { - // // - // XCBullishOrderBlockObject *iObj; - // bool isCreated = mPOIDrawer.CreateBullishOrderBlock( - // orderBlock, - // iObj // - // ); - // if (isCreated) - // { - // AddObjectIfNotExists(iObj); - // } - // } - // else - // { - // // - // XCBearishOrderBlockObject *iObj; - // bool isCreated = mPOIDrawer.CreateBearishOrderBlock( - // orderBlock, - // iObj // - // ); - // if (isCreated) - // { - // AddObjectIfNotExists(iObj); - // } - // } - - // - XCSupplyZone *supplyZone; - int supplyCount = state.CountSupplyZones(); - if (IsValidSize(supplyCount)) - { - // - for (int i = 0; i < supplyCount; i++) - { - // - XCSupplyZone *iZone = state.supplyZones[i]; - isPeakInsideSupplyZone = peak >= iZone.Lower() && - peak <= iZone.Upper() && - bid >= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); - if (isPeakInsideSupplyZone) - { - // - supplyZone = iZone; - break; - } - } - } - - // - XCDemandZone *demandZone; - int demandCount = state.CountDemandZones(); - if (IsValidSize(demandCount)) - { - // - for (int i = 0; i < demandCount; i++) - { - // - XCDemandZone *iZone = state.demandZones[i]; - isValeInsideDemandZone = vale >= iZone.Lower() && - vale <= iZone.Upper() && - bid <= iZone.Lower() + ((iZone.Upper() - iZone.Lower()) / zoneVerificationDivider); - if (isValeInsideDemandZone) - { - // - demandZone = iZone; - break; - } - } - } - - // - bool isPeakAttacked = - isNewPeak && - isSarBearish && - pBar.high == peak && - isPeakInsideSupplyZone && - isClosedUnderDonCloseUpper; - - // - bool isValeAttacked = - isNewVale && - isSarBullish && - pBar.low == vale && - isValeInsideDemandZone && - isClosedOverDonCloseLower; - - // - result = isPeakAttacked || - isValeAttacked; - if (!result) - { - return result; - } - - // - if (isPeakAttacked) - { - // - supplyZone.To(TimeCurrent()); - XCSupplyZoneObject *iObj; - bool isCreated = mPOIDrawer.CreateSupplyZone( - supplyZone, - iObj // - ); - if (isCreated) - { - AddObjectIfNotExists(iObj); - } - } - else - { - // - demandZone.To(TimeCurrent()); - XCDemandZoneObject *iObj; - bool isCreated = mPOIDrawer.CreateDemandZone( - demandZone, - iObj // - ); - if (isCreated) - { - AddObjectIfNotExists(iObj); - } - } - - // - bool isBullish = - // - isValeAttacked - // - ; - - // - bool isBearish = - // - isPeakAttacked - // - ; - - // - result = - // - isBullish || - isBearish - // - ; - if (!result) - { - return result; - } - - // - // Set SL, Provider and Direction ... - conditions.signalDir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - conditions.provider = providerStr; - - // - conditions.sl = - isBullish - ? demandZone.Lower() - : supplyZone.Upper(); - - // - return result; - } - - /** - * Detect and Parse Market Conditions for Signalling ... - * - * @param conditions: X121SMCStrategyConditions instance Reference ... - * - * @return ( bool ) - */ - // TODO: Required Calibrate ... - bool DetectVWAPCSignal( - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - return false; - - // - string symbol = GetSymbol(); - ENUM_TIMEFRAMES period = GetPeriod(); - - // - int zIndex = 0; - int cIndex = zIndex + 1; - int pIndex = cIndex + 1; - int ppIndex = pIndex + 1; - - // - XOHCL zBar; - result = zBar.Init( - symbol, - period, - zIndex // - ); - if (!result) - { - return result; - } - - // - XOHCL cBar; - result = cBar.Init( - symbol, - period, - cIndex // - ); - if (!result) - { - return result; - } - - // - string msg = NULL; - - // - double bid = GetBid(symbol); - datetime cTime = TimeCurrent(); - - // - ENUM_X_121_SMC_PROVIDERS provider = X_121_SMC_PROVIDER_VWAPC; - string providerStr = ToString(provider); - - // - // Check Candlestic State ... - ENUM_X_DIRECTION candlesticDir; - result = DetectCandlestic( - provider, - candlesticDir, - conditions // - ); - if (!result) - { - return result; - } - - // - // Check Sar State ... - ENUM_X_DIRECTION sarDir; - result = DetectSarState( - provider, - sarDir, - conditions // - ); - if (!result) - { - return result; - } - - // - // Check VWAP State ... - ENUM_X_DIRECTION vwapDir; - result = DetectVWapState( - provider, - vwapDir, - conditions // - ); - if (!result) - { - return result; - } - - // - bool isBullish = - // - IsBullish(sarDir) && - IsBullish(vwapDir) && - IsBullish(candlesticDir) - // - ; - - // - bool isBearish = - // - IsBearish(sarDir) && - IsBearish(vwapDir) && - IsBearish(candlesticDir) - // - ; - - // - result = - // - isBullish || - isBearish - // - ; - - // - Print("VWap Signal ..."); - - // - if (!result) - { - return result; - } - - // - return result; - } - // // TODO: Remove this ... - XTestProiderConditions mTestConditions; + XSMCStrategySetupConditions mTestConditions; bool DetectTestSignal( X121SMCStrategyConditions &conditions // ) @@ -1334,16 +534,16 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy bool isBearish = false; // + double ask = GetAsk(symbol); double bid = GetBid(symbol); datetime cTime = TimeCurrent(); // - double selectedSL = 0; + double ll = cBar.FindLowest(9, MODE_LOW); + double hh = cBar.FindHighest(9, MODE_HIGH); // - // Retrieve Peak and Vale ... - double peak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; - double vale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; + double selectedSL = 0; // X121SMCCycleConditions triggerConditions = conditions.triggerConditions; @@ -1361,1674 +561,297 @@ class XCX121SMCTestStrategy : public XCX121SMCBaseStrategy XPOIState consolidationState = consolidationConditions.state; XPOIState visionState = visionConditions.state; + // + // Retrieve Peak and Vale ... + double triggerPeak = triggerConditions.x121Conditions.peaksBuffer[0]; + double triggerVale = triggerConditions.x121Conditions.valesBuffer[0]; + // int zoneValidationDivider = 10; + int validPivotRepetition = mTriggerCycleHelper.mX121Helper + .GetDonChainLength(); // - // Try to Detect Setup Conditions ... - ENUM_X_DIRECTION setupDir; - result = mTestConditions.IsSetuped(setupDir); - if (!result) + datetime setupTime = NULL; + bool isSetuped = mTestConditions.IsSetuped(); + ENUM_X_DIRECTION setupDir = mTestConditions.dir; + if (!isSetuped) { // - // First we must check a new Peak or Vale Happens ... - bool isNewPeak = conditions.triggerConditions.x121Conditions.isNewPeak; - bool isNewVale = conditions.triggerConditions.x121Conditions.isNewVale; + // Detect Valid Peaks and Vales ... // - result = isNewPeak || - isNewVale; - if (!result) - { - return result; - } - - // - mTestConditions.isNewPeak = isNewPeak; - mTestConditions.isNewVale = isNewVale; - - // - // We have to Check the Peaks and Vales Happens inside a Demand or Supply Zone ... - // in Vision State ... - - // - bool hasVisionSupplyZone = false; - XCSupplyZone *visionSupplyZone = NULL; - int visionSupplyZonesCount = visionState.CountSupplyZones(); - if (isNewPeak && - IsValidSize(visionSupplyZonesCount)) + // Peaks ... + XPVPivotPoint validPeak = mTestConditions.validPeak; + bool hasValidPeak = validPeak.IsValid(); + if (!hasValidPeak) { // - // Try to Find Inside Zone ... - for (int i = 0; i < visionSupplyZonesCount; i++) + // Detecte Valid Peaks ... + + // + XPVPivotPoint triggerValidPeaks[]; + int triggerValidPeaksCount = mTriggerCycleHelper + .FillPeakPivotPoints(triggerValidPeaks); + + // + bool isValid = + IsValidSize(triggerValidPeaksCount); + if (isValid) { // - XCSupplyZone *iZone = visionState.supplyZones[i]; - double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; - - // - hasVisionSupplyZone = - // - peak >= iZone.Lower() && - peak <= iZone.Upper() && - peak > iZone.Upper() - zoneValidRange - // - ; - if (hasVisionSupplyZone) + // Try to Find ... + for (int i = triggerValidPeaksCount - 1; i >= 0; i--) { // - visionSupplyZone = iZone; - break; + XPVPivotPoint iPivot = triggerValidPeaks[i]; + double iValue = iPivot.value; + + // + bool isValid = iValue == triggerConditions.x121Conditions.peaksBuffer[0] && + iValue == decisionConditions.x121Conditions.peaksBuffer[0] && + iValue == analyseConditions.x121Conditions.peaksBuffer[0] && + iValue == verificationConditions.x121Conditions.peaksBuffer[0]; + if (isValid) + { + // + validPeak = iPivot; + break; + } + } + + // + hasValidPeak = validPeak.IsValid(); + if (hasValidPeak) + { + // + mTestConditions.validPeak = validPeak; + + // + if (!mTestConditions.validVale.IsValid()) + { + // + XValueChange valesChanges[]; + int valeChangesCount = mTriggerCycleHelper.FillValesChanges(valesChanges); + if (IsValidSize(valeChangesCount)) + { + // + XValueChange lastChange = valesChanges[valeChangesCount - 1]; + if (lastChange.IsValid()) + { + // + XPVPivotPoint iPivot; + iPivot.repetition = 1; + iPivot.type = XPV_VALE; + iPivot.time = lastChange.time; + iPivot.value = lastChange.after; + if (iPivot.IsValid()) + { + mTestConditions.validVale = iPivot; + } + } + } + } } } } // - bool hasVisionDemandZone = false; - XCDemandZone *visionDemandZone = NULL; - int visionDemandZonesCount = visionState.CountDemandZones(); - if (isNewVale && - IsValidSize(visionDemandZonesCount)) + // Vales ... + XPVPivotPoint validVale = mTestConditions.validVale; + bool hasValidVale = validVale.IsValid(); + if (!hasValidVale) { // - // Try to Find Inside Zone ... - for (int i = 0; i < visionDemandZonesCount; i++) + // Detecte Valid Vale ... + + // + XPVPivotPoint triggerValidVales[]; + int triggerValidValesCount = mTriggerCycleHelper + .FillValePivotPoints(triggerValidVales); + + // + bool isValid = + IsValidSize(triggerValidValesCount); + if (isValid) { // - XCDemandZone *iZone = visionState.demandZones[i]; - double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; - - // - hasVisionDemandZone = - // - vale >= iZone.Lower() && - vale <= iZone.Upper() && - vale < iZone.Lower() + zoneValidRange - // - ; - if (hasVisionDemandZone) + // Try to Find ... + for (int i = triggerValidValesCount - 1; i >= 0; i--) { // - visionDemandZone = iZone; - break; + XPVPivotPoint iPivot = triggerValidVales[i]; + double iValue = iPivot.value; + + // + bool isValid = iValue == triggerConditions.x121Conditions.valesBuffer[0] && + iValue == decisionConditions.x121Conditions.valesBuffer[0] && + iValue == analyseConditions.x121Conditions.valesBuffer[0] && + iValue == verificationConditions.x121Conditions.valesBuffer[0]; + if (isValid) + { + // + validVale = iPivot; + break; + } + } + + // + hasValidVale = validVale.IsValid(); + if (hasValidVale) + { + // + mTestConditions.validVale = validVale; + + // + if (!mTestConditions.validPeak.IsValid()) + { + // + XValueChange valesChanges[]; + int valeChangesCount = mTriggerCycleHelper.FillPeaksChanges(valesChanges); + if (IsValidSize(valeChangesCount)) + { + // + XValueChange lastChange = valesChanges[valeChangesCount - 1]; + if (lastChange.IsValid()) + { + // + XPVPivotPoint iPivot; + iPivot.repetition = 1; + iPivot.type = XPV_PEAK; + iPivot.time = lastChange.time; + iPivot.value = lastChange.after; + if (iPivot.IsValid()) + { + mTestConditions.validPeak = iPivot; + } + } + } + } } } } - - // - result = hasVisionSupplyZone || - hasVisionDemandZone; + bool hasValidPivot = hasValidPeak && + hasValidVale; + result = hasValidPivot; if (!result) { return result; } // - mTestConditions.visionSupplyZone = visionSupplyZone; - mTestConditions.visionDemandZone = visionDemandZone; + mTestConditions.peak = triggerPeak; + mTestConditions.vale = triggerVale; // - mTestConditions.hasVisionSupplyZone = hasVisionSupplyZone; - mTestConditions.hasVisionDemandZone = hasVisionDemandZone; - - // - double triggerPeak = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; - double decisionPeak = conditions.decisionConditions.x121Conditions.peaksBuffer[0]; - double analysePeak = conditions.analyseConditions.x121Conditions.peaksBuffer[0]; - double verificationPeak = conditions.verificationConditions.x121Conditions.peaksBuffer[0]; - double consolidationPeak = conditions.consolidationConditions.x121Conditions.peaksBuffer[0]; - double visionPeak = conditions.visionConditions.x121Conditions.peaksBuffer[0]; - - // - bool isPeaksSame = - // - triggerPeak && - decisionPeak && - analysePeak && - verificationPeak && - consolidationPeak && - visionPeak - // - ; - - // - double triggerVale = conditions.triggerConditions.x121Conditions.valesBuffer[0]; - double decisionVale = conditions.decisionConditions.x121Conditions.valesBuffer[0]; - double analyseVale = conditions.analyseConditions.x121Conditions.valesBuffer[0]; - double verificationVale = conditions.verificationConditions.x121Conditions.valesBuffer[0]; - double consolidationVale = conditions.consolidationConditions.x121Conditions.valesBuffer[0]; - double visionVale = conditions.visionConditions.x121Conditions.valesBuffer[0]; - - // - bool isValesSame = - // - triggerVale && - decisionVale && - analyseVale && - verificationVale && - consolidationVale && - visionVale - // - ; - - // - mTestConditions.hasSamePeaks = isPeaksSame; - mTestConditions.hasSameVales = isValesSame; - - // - isBullish = - // - isNewVale && - isPeaksSame && - isValesSame && - hasVisionDemandZone - // - ; - - // - isBearish = - // - isNewPeak && - isPeaksSame && - isValesSame && - hasVisionSupplyZone - // - ; - - // - result = - isBullish || - isBearish; - if (!result) - { - return result; - } - - // - mTestConditions.setupTime = TimeCurrent(); - - // - result = mTestConditions.IsSetuped(setupDir); - if (!result) - { - return result; - } - - // - // Alert ... - string message = providerStr + " Conditions Set Upped: " + ToString(setupDir); - Alert(message); - } - else - { - // - // Try to Detect Trigger Conditions ... - mTestConditions.symbol = symbol; - mTestConditions.period = period; - - // - // Try to Find Support Zone which Vales Inside it ... - bool hasConsolidationSupportZone = false; - XCSupportZone *consolidationSupportZone = NULL; - int consolidationSupportZonesCount = consolidationState.CountSupportZones(); - if (IsValidSize(consolidationSupportZonesCount)) + // We Sure we Have Valid Peak and Valid Vale ... + // Create a Zone ... + bool hasZone = mTestConditions.zone.IsValid(); + if (!hasZone) { // - for (int i = 0; i < consolidationSupportZonesCount; i++) - { - // - XCSupportZone *iZone = consolidationState.supportZones[i]; - // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; - - // - hasConsolidationSupportZone = - // - peak >= iZone.Lower() && - peak <= iZone.Upper() - // && - // vale < iZone.Upper() - zoneValidRange - // - ; - if (hasConsolidationSupportZone) - { - // - consolidationSupportZone = iZone; - break; - } - } - } - - // - // Try to Find Resistance Zone which Peaks Inside it ... - bool hasConsolidationResistanceZone = false; - XCResistanceZone *consolidationResistanceZone = NULL; - int consolidationResistanceZonesCount = consolidationState.CountResistanceZones(); - if (IsValidSize(consolidationResistanceZonesCount)) - { - // - for (int i = 0; i < consolidationResistanceZonesCount; i++) - { - // - XCResistanceZone *iZone = consolidationState.resistanceZones[i]; - // double zoneValidRange = (iZone.Upper() - iZone.Lower()) / zoneValidationDivider; - - // - hasConsolidationResistanceZone = - // - vale >= iZone.Lower() && - vale <= iZone.Upper() - // && - // peak > iZone.Lower() + zoneValidRange - // - ; - if (hasConsolidationResistanceZone) - { - // - consolidationResistanceZone = iZone; - break; - } - } - } - - // - result = hasConsolidationSupportZone || - hasConsolidationResistanceZone; - if (!result) - { - return result; - } - - // - result = - // - (IsBullish(setupDir) && - hasConsolidationResistanceZone) - // - || - // - (IsBearish(setupDir) && - hasConsolidationSupportZone) - // - ; - if (!result) - { - return result; - } - - // - // Detect State Conditions ... - - // - // Vision ... - - // - bool isVisionBullishPassed = - // - // Sar ... - visionConditions.x121Conditions.isSarBullish - // - && - // - // VWap ... - visionConditions.x121Conditions.isVWapFastBullish - // - ; - - // - bool isVisionBearishPassed = - // - // Sar ... - visionConditions.x121Conditions.isSarBearish - // - && - // - // VWap ... - visionConditions.x121Conditions.isVWapFastBearish - // - ; - - // - bool isVisionPassed = isVisionBullishPassed || - isVisionBearishPassed; - result = isVisionPassed; - if (!result) - { - return result; - } - - // - // Consolidation ... - - // - bool isConsolidationBullishPassed = - // - // Sar ... - consolidationConditions.x121Conditions.isSarBullish - // - && - // - // VWap State ... - consolidationConditions.x121Conditions.isVWapBullishState - // - && - // - // VWap Order ... - consolidationConditions.x121Conditions.isVWapBullishOrdered - // - ; - - // - bool isConsolidationBearishPassed = - // - // - // Sar ... - consolidationConditions.x121Conditions.isSarBearish - // - && - // - // VWap State ... - consolidationConditions.x121Conditions.isVWapBearishState - // - && - // - // VWap Order ... - consolidationConditions.x121Conditions.isVWapBearishOrdered - // - ; - - // - bool isConsolidationPassed = isConsolidationBullishPassed || - isConsolidationBearishPassed; - result = isConsolidationPassed; - if (!result) - { - return result; - } - - // - // Verification ... - - // - bool isVerificationBullishPassed = - // - // Sar ... - verificationConditions.x121Conditions.isSarBullish - // - && - // - // VWap State ... - verificationConditions.x121Conditions.isVWapBullishState - // - && - // - // VWap Order ... - verificationConditions.x121Conditions.isVWapBullishOrdered - // - ; - - // - bool isVerificationBearishPassed = - // - // Sar ... - verificationConditions.x121Conditions.isSarBearish - // - && - // - // VWap State ... - verificationConditions.x121Conditions.isVWapBearishState - // - && - // - // VWap Order ... - verificationConditions.x121Conditions.isVWapBearishOrdered - // - ; - - // - bool isVerificationPassed = isVerificationBullishPassed || - isVerificationBearishPassed; - result = isVerificationPassed; - if (!result) - { - return result; - } - - // - // Analyse ... - - // - bool isAnalyseBullishPassed = - // - // Sar ... - analyseConditions.x121Conditions.isSarBullish - // - && - // - // VWap Order ... - analyseConditions.x121Conditions.isVWapBullishOrdered - // - && - // - // VWap State ... - (analyseConditions.x121Conditions.isVWapBullishState || - (analyseConditions.x121Conditions.isVWapMidBullish && - analyseConditions.x121Conditions.isVWapSlowBullish)) - // - ; - - // - bool isAnalyseBearishPassed = - // - // Sar ... - analyseConditions.x121Conditions.isSarBearish - // - && - // - // VWap Order ... - analyseConditions.x121Conditions.isVWapBearishOrdered - // - && - // - // VWap State ... - (analyseConditions.x121Conditions.isVWapBearishState || - (analyseConditions.x121Conditions.isVWapMidBearish && - analyseConditions.x121Conditions.isVWapSlowBearish)) - // - ; - - // - bool isAnalysePassed = isAnalyseBullishPassed || - isAnalyseBearishPassed; - result = isAnalysePassed; - if (!result) - { - return result; - } - - // - // Decision ... - - // - double decisionPeak = decisionConditions.x121Conditions.peaksBuffer[1]; - double decisionVale = decisionConditions.x121Conditions.valesBuffer[1]; - - // - XOHCL decisionCBar; - result = mDecisionCycleHelper.GetBar( - decisionCBar, - cIndex // - ); - - // - // Check Fibo Pressure ... - ENUM_X_DIRECTION pressureDir; - bool hasPressurePin = mBarAnalyser.HasFiboPressure( - decisionCBar, - pressureDir // - ); - - // - bool isBarBullish = - // - (hasPressurePin && - IsBullish(pressureDir)) - // - && - // - decisionCBar.low == decisionVale - // - ; - - // - bool isBarBearish = - // - (hasPressurePin && - IsBearish(pressureDir)) - // - && - // - decisionCBar.high == decisionPeak - // - ; - - // - bool isBarPassed = isBarBullish || - isBarBearish; - result = isBarPassed; - if (!result) - { - return result; - } - - // - bool isDecisionBullishPassed = - // - // Bar ... - isBarBullish - // - && - // - // VWap Order ... - decisionConditions.x121Conditions.isVWapBullishOrdered - // - ; - - // - bool isDecisionBearishPassed = - // - // Bar ... - isBarBearish - // - && - // - // VWap Order ... - decisionConditions.x121Conditions.isVWapBearishOrdered - // - ; - - // - bool isDecisionPassed = isDecisionBullishPassed || - isDecisionBearishPassed; - result = isDecisionPassed; - if (!result) - { - return result; - } - - // - // Trigger ... - - // - double donOpenUpper = triggerConditions.x121Conditions.donOpenUpperBuffer[1]; - double donOpenLower = triggerConditions.x121Conditions.donOpenLowerBuffer[1]; - - // - double donCloseUpper = triggerConditions.x121Conditions.donCloseUpperBuffer[1]; - double donCloseLower = triggerConditions.x121Conditions.donCloseLowerBuffer[1]; - - // - bool isDonBullish = - // - donCloseLower > donOpenUpper - // - && - // - cBar.low > donCloseLower && - cBar.high > donCloseLower - // - ; - - // - bool isDonBearish = - // - donOpenUpper > donCloseUpper - // - && - // - cBar.low < donCloseUpper && - cBar.high < donCloseUpper - // - ; - - // - bool isTriggerBullishPassed = - // - // Don ... - isDonBullish - // - && - // - // Sar ... - triggerConditions.x121Conditions.isSarBullish - // - ; - - // - bool isTriggerBearishPassed = - // - // Don ... - isDonBearish - // - && - // - // Sar ... - triggerConditions.x121Conditions.isSarBearish - // - ; - - // - bool isTriggerPassed = isTriggerBullishPassed || - isTriggerBearishPassed; - result = isTriggerPassed; - if (!result) - { - return result; - } - - // - // - // - - // - bool isBullishTriggerConditionsPassed = - // - isConsolidationBullishPassed && - isVerificationBullishPassed && - isAnalyseBullishPassed && - isDecisionBullishPassed && - isTriggerBullishPassed - // - ; - - // - bool isBearishTriggerConditionsPassed = - // - isConsolidationBearishPassed && - isVerificationBearishPassed && - isAnalyseBearishPassed && - isDecisionBearishPassed && - isTriggerBearishPassed - // - ; - - // - // - // - - // - bool isBullish = - // - IsBullish(setupDir) && - hasConsolidationSupportZone && - isBullishTriggerConditionsPassed - // - ; - - // - bool isBearish = - // - IsBearish(setupDir) && - hasConsolidationResistanceZone && - isBearishTriggerConditionsPassed - // - ; - - // - result = - isBullish || - isBearish; - if (!result) - { - return result; - } - - // - double entry = GetEntry( - symbol, - setupDir // - ); - double spread = GetSpread( - symbol // - ); - - // - zoneValidationDivider = 8; - double selectedSL = isBullish - ? consolidationResistanceZone.Upper() - spread - - ((consolidationResistanceZone.Upper() - consolidationResistanceZone.Lower()) / - zoneValidationDivider) - : consolidationSupportZone.Lower() + spread + - ((consolidationSupportZone.Upper() - consolidationSupportZone.Lower()) / - zoneValidationDivider); - - // - mTestConditions.sl = selectedSL; - mTestConditions.type = - isBullish - ? X_POSITION_TYPE_LONG - : X_POSITION_TYPE_SHORT; - mTestConditions.triggerTime = TimeCurrent(); - } - - // - // Check Conditions is Prepared for Trigger ... - result = mTestConditions.CanTrigger(); - if (!result) - { - return result; - } - - // - conditions.signalDir = setupDir; - conditions.provider = providerStr; - conditions.sl = mTestConditions.sl; - - // - mTestConditions.Clean(); - - // - return result; - } - - // - // Helper Functions ... - - /** - * Detect Where Cycles has Same Peaks ... - * - * @param cycles: ENUM_X_CYCLES members, Array ... - * @param conditions: X121SMCStrategyConditions instance, Reference ... - * - * @return ( bool ) - */ - bool DetectSamePeaks( - ENUM_X_CYCLES &cycles[], - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - int count = ArraySize(cycles); - result = IsValidSize(count); - if (!result) - { - return result; - } - - // - double value = -1; - for (int i = 0; i < count; i++) - { - // - ENUM_X_CYCLES iCycle = cycles[i]; - - // - double iValue = -1; - switch (iCycle) - { - // - case X_CYCLE_TRIGGER: - iValue = conditions.triggerConditions.x121Conditions.peaksBuffer[0]; - break; - - // - case X_CYCLE_DECISION: - iValue = conditions.decisionConditions.x121Conditions.peaksBuffer[0]; - break; - - // - case X_CYCLE_ANALYSE: - iValue = conditions.analyseConditions.x121Conditions.peaksBuffer[0]; - break; - - // - case X_CYCLE_VERIFICATION: - iValue = conditions.verificationConditions.x121Conditions.peaksBuffer[0]; - break; - - // - case X_CYCLE_CONSOLIDATION: - iValue = conditions.consolidationConditions.x121Conditions.peaksBuffer[0]; - break; - - // - case X_CYCLE_VISION: - iValue = conditions.visionConditions.x121Conditions.peaksBuffer[0]; - break; - } - - // - if (iValue > 0) - { - // - if (value <= 0) - { - value = iValue; - } - - // - result = value == iValue; + double pvZoneUpper = validPeak.value; + double pvZoneLower = validVale.value; + datetime pvZoneFrom = + validPeak.time < validVale.time + ? validPeak.time + : validVale.time; + int pvZoneLoopback = iBarShift( + symbol, + period, + pvZoneFrom // + ); + + // + XConsolidationZone pvZone; + result = pvZone.Init( + symbol, + period, + pvZoneUpper, + pvZoneLower, + pvZoneLoopback // + ); if (!result) { - break; + return result; } + + // + mTestConditions.zone = pvZone; + hasZone = mTestConditions.zone.IsValid(); } - } - - // - return result; - } - - /** - * Detect Where Cycles has Same Vales ... - * - * @param cycles: ENUM_X_CYCLES members, Array ... - * @param conditions: X121SMCStrategyConditions instance, Reference ... - * - * @return ( bool ) - */ - bool DetectSameVales( - ENUM_X_CYCLES &cycles[], - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - int count = ArraySize(cycles); - result = IsValidSize(count); - if (!result) - { - return result; - } - - // - double value = -1; - for (int i = 0; i < count; i++) - { - // - ENUM_X_CYCLES iCycle = cycles[i]; - - // - double iValue = -1; - switch (iCycle) - { - // - case X_CYCLE_TRIGGER: - iValue = conditions.triggerConditions.x121Conditions.valesBuffer[0]; - break; - - // - case X_CYCLE_DECISION: - iValue = conditions.decisionConditions.x121Conditions.valesBuffer[0]; - break; - - // - case X_CYCLE_ANALYSE: - iValue = conditions.analyseConditions.x121Conditions.valesBuffer[0]; - break; - - // - case X_CYCLE_VERIFICATION: - iValue = conditions.verificationConditions.x121Conditions.valesBuffer[0]; - break; - - // - case X_CYCLE_CONSOLIDATION: - iValue = conditions.consolidationConditions.x121Conditions.valesBuffer[0]; - break; - - // - case X_CYCLE_VISION: - iValue = conditions.visionConditions.x121Conditions.valesBuffer[0]; - break; - } - - // - if (iValue > 0) + if (hasZone) { // - if (value <= 0) - { - value = iValue; - } + // Update Zone ... + mTestConditions.UpdateZone(); // - result = value == iValue; - if (!result) + XCConsolidationZoneObject *iPVZoneObj; + iPVZoneObj = new XCConsolidationZoneObject(); + bool isCreated = iPVZoneObj.Create( + mPOIDrawer.ChartIdentification(), + mPOIDrawer.SubWindowIdentification(), + mTestConditions.zone // + ); + if (isCreated) { - break; + // + iPVZoneObj.ZoneWidth(4); + iPVZoneObj.ZoneColor(clrGold); + + // + AddObjectIfNotExists(iPVZoneObj); } } + + // + // Here we Have to Check Price Go into Zone ... + bool isZoneBreaked = mTestConditions.zone.IsBreaked(); + result = isZoneBreaked; + if (!result) + { + return result; + } + + // + isSetuped = true; + setupTime = cTime; + mTestConditions.setupTime = setupTime; + setupDir = mTestConditions.zone.breakDirection; + mTestConditions.dir = setupDir; } // - return result; - } - - /** - * Detect Sar State for Signalling ... - * - * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... - * @param dir: ENUM_X_DIRECTION member Reference ... - * @param conditions: X121SMCStrategyConditions instance, Reference ... - * - * @return ( bool ) - */ - bool DetectSarState( - ENUM_X_121_SMC_PROVIDERS forProvider, - ENUM_X_DIRECTION &dir, - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - dir = X_DIRECTION_NONE; - - // - bool isBullish = false; - bool isBearish = false; - - // - if (forProvider == X_121_SMC_PROVIDER_SMPV) + // Setup Forms ... + bool canTrigger = mTestConditions.CanTrigger(); + if (!canTrigger) { // - isBullish = + // Check Trigger Consitions ... + if (cTime - setupTime > 2400) + { // - // Check One of Verification or Consolidation Cycles Must be Sar Bullish ... - (conditions.verificationConditions.x121Conditions.isSarBullish || - conditions.consolidationConditions.x121Conditions.isSarBullish) - // - && - // - // Decision and Analyse Cycles Must be Bullish ... - (conditions.decisionConditions.x121Conditions.isSarBullish && - conditions.analyseConditions.x121Conditions.isSarBullish) - // - && - // - // Trigger State Must be Bearish ... - conditions.triggerConditions.x121Conditions.isSarBearish - // - ; + ClearDraws(); - // - isBearish = // - // Check One of Verification or Consolidation Cycles Must be Sar Bearish ... - (conditions.verificationConditions.x121Conditions.isSarBearish || - conditions.consolidationConditions.x121Conditions.isSarBearish) - // - && - // - // Decision and Analyse Cycles Must be Bearish ... - (conditions.decisionConditions.x121Conditions.isSarBearish && - conditions.analyseConditions.x121Conditions.isSarBearish) - // - && - // - // Trigger State Must be Bullish ... - conditions.triggerConditions.x121Conditions.isSarBullish - // - ; + mTestConditions.Clean(); + return false; + } + + // // + // canTrigger = true; + // mTestConditions.triggerTime = cTime; } // - if (forProvider == X_121_SMC_PROVIDER_RJBPV) - { - // - isBullish = - // - // Trigger, Decision and Analyse must be Directional ... - conditions.triggerConditions.x121Conditions.isSarBullish && - conditions.decisionConditions.x121Conditions.isSarBullish && - conditions.analyseConditions.x121Conditions.isSarBullish - // - ; - - // - isBearish = - // - // Trigger, Decision and Analyse must be Directional ... - conditions.triggerConditions.x121Conditions.isSarBearish && - conditions.decisionConditions.x121Conditions.isSarBearish && - conditions.analyseConditions.x121Conditions.isSarBearish - // - ; - } + // Issues Signal on Conditions ... + // conditions.signalDir = mTestConditions.dir; + // conditions.provider = providerStr; + // conditions.sl = mTestConditions.sl; // - if (forProvider == X_121_SMC_PROVIDER_VWAPC) - { - // - isBullish = - // - // All Cycles Sars Must be Directional exept Vision ... - conditions.triggerConditions.x121Conditions.isSarBullish && - conditions.decisionConditions.x121Conditions.isSarBullish && - conditions.analyseConditions.x121Conditions.isSarBullish && - conditions.verificationConditions.x121Conditions.isSarBullish && - conditions.consolidationConditions.x121Conditions.isSarBullish - // - ; - - // - isBearish = - // - // All Cycles Sars Must be Directional exept Vision ... - conditions.triggerConditions.x121Conditions.isSarBearish && - conditions.decisionConditions.x121Conditions.isSarBearish && - conditions.analyseConditions.x121Conditions.isSarBearish && - conditions.verificationConditions.x121Conditions.isSarBearish && - conditions.consolidationConditions.x121Conditions.isSarBearish - // - ; - } - - // - result = isBullish || - isBearish; - if (!result) - { - return result; - } - - // - dir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - - // - return result; - } - - /** - * Detect Sar State for Signalling ... - * - * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... - * @param dir: ENUM_X_DIRECTION member Reference ... - * @param conditions: X121SMCStrategyConditions instance, Reference ... - * - * @return ( bool ) - */ - bool DetectVWapState( - ENUM_X_121_SMC_PROVIDERS forProvider, - ENUM_X_DIRECTION &dir, - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - dir = X_DIRECTION_NONE; - - // - bool isBullish = false; - bool isBearish = false; - - // - if (forProvider == X_121_SMC_PROVIDER_SMPV) - { - // - isBullish = - // - // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ... - // - // Orders ... - (conditions.triggerConditions.x121Conditions.isVWapBullishOrdered && - conditions.decisionConditions.x121Conditions.isVWapBullishOrdered && - conditions.analyseConditions.x121Conditions.isVWapBullishOrdered) - // - && - // - // State ... - (conditions.triggerConditions.x121Conditions.isVWapBullishState && - conditions.decisionConditions.x121Conditions.isVWapBullishState && - conditions.analyseConditions.x121Conditions.isVWapBullishState) - // - && - // - // One of Verification and Consolidation must Be in Direction State ... - (conditions.verificationConditions.x121Conditions.isVWapBullishState || - conditions.consolidationConditions.x121Conditions.isVWapBullishState) - // - ; - - // - isBearish = - // - // Trigger, Decision and Analyse Cycles Must be in Direction Order and State ... - // - // Orders ... - (conditions.triggerConditions.x121Conditions.isVWapBearishOrdered && - conditions.decisionConditions.x121Conditions.isVWapBearishOrdered && - conditions.analyseConditions.x121Conditions.isVWapBearishOrdered) - // - && - // - // State ... - (conditions.triggerConditions.x121Conditions.isVWapBearishState && - conditions.decisionConditions.x121Conditions.isVWapBearishState && - conditions.analyseConditions.x121Conditions.isVWapBearishState) - // - && - // - // One of Verification and Consolidation must Be in Direction State ... - (conditions.verificationConditions.x121Conditions.isVWapBearishState || - conditions.consolidationConditions.x121Conditions.isVWapBearishState) - // - ; - } - - // - if (forProvider == X_121_SMC_PROVIDER_VWAPC) - { - // - isBullish = - // - // All Cycles Must be State and Ordered Directional Except Vision ... - // State ... - conditions.triggerConditions.x121Conditions.isVWapBullishState && - conditions.decisionConditions.x121Conditions.isVWapBullishState && - conditions.analyseConditions.x121Conditions.isVWapBullishState && - conditions.verificationConditions.x121Conditions.isVWapBullishState && - conditions.consolidationConditions.x121Conditions.isVWapBullishState - // - && - // Order ... - conditions.triggerConditions.x121Conditions.isVWapBullishOrdered && - conditions.decisionConditions.x121Conditions.isVWapBullishOrdered && - conditions.analyseConditions.x121Conditions.isVWapBullishOrdered && - conditions.verificationConditions.x121Conditions.isVWapBullishOrdered && - conditions.consolidationConditions.x121Conditions.isVWapBullishOrdered - // - ; - - // - isBearish = - // - // All Cycles Must be State and Ordered Directional Except Vision ... - // State ... - conditions.triggerConditions.x121Conditions.isVWapBearishState && - conditions.decisionConditions.x121Conditions.isVWapBearishState && - conditions.analyseConditions.x121Conditions.isVWapBearishState && - conditions.verificationConditions.x121Conditions.isVWapBearishState && - conditions.consolidationConditions.x121Conditions.isVWapBearishState - // - && - // Order ... - conditions.triggerConditions.x121Conditions.isVWapBearishOrdered && - conditions.decisionConditions.x121Conditions.isVWapBearishOrdered && - conditions.analyseConditions.x121Conditions.isVWapBearishOrdered && - conditions.verificationConditions.x121Conditions.isVWapBearishOrdered && - conditions.consolidationConditions.x121Conditions.isVWapBearishOrdered - // - ; - } - - // - result = isBullish || - isBearish; - if (!result) - { - return result; - } - - // - dir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; - - // - return result; - } - - /** - * Detect Candlestic Patters for Signalling ... - * - * @param forProvider: ENUM_X_121_SMC_PROVIDERS member ... - * @param dir: ENUM_X_DIRECTION member Reference ... - * @param conditions: X121SMCStrategyConditions instance, Reference ... - * - * @return ( bool ) - */ - bool DetectCandlestic( - ENUM_X_121_SMC_PROVIDERS forProvider, - ENUM_X_DIRECTION &dir, - X121SMCStrategyConditions &conditions // - ) - { - // - bool result = false; - - // - dir = X_DIRECTION_NONE; - - // - int cIndex = 1; - int pIndex = cIndex + 1; - - // - // Select Specified Cycle Helper ... - XC121SMCCycleHelper *cycleHelper = mTriggerCycleHelper; - - // - string symbol = GetSymbol(); - ENUM_TIMEFRAMES period = cycleHelper.GetPeriod(); - - // - XOHCL cBar; - result = cBar.Init( - symbol, - period, - cIndex // - ); - if (!result) - { - return result; - } - - // - // Momentum Bar ... - ENUM_X_DIRECTION cBarMomentumDir; - bool isCBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar( - cBar, - cBarMomentumDir // - ); - - // - // Rejection Bar ... - ENUM_X_DIRECTION cBarRejectionDir; - bool isCBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar( - cBar, - cBarRejectionDir // - ); - - // - // Engulf Bar ... - ENUM_X_DIRECTION cBarEngulfDir; - bool isCBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar( - cBar, - cBarEngulfDir // - ); - - // - // Pin Bar ... - ENUM_X_DIRECTION cBarPinDir; - bool isCBarPin = cycleHelper.mBarAnalyser.IsPinBar( - cBar, - cBarPinDir // - ); - - // - XOHCL pBar; - result = pBar.Init( - symbol, - period, - pIndex // - ); - if (!result) - { - return result; - } - - // - // Momentum Bar ... - ENUM_X_DIRECTION pBarMomentumDir; - bool isPBarMomentum = cycleHelper.mBarAnalyser.IsMomentumBar( - pBar, - pBarMomentumDir // - ); - - // - // Rejection Bar ... - ENUM_X_DIRECTION pBarRejectionDir; - bool isPBarRejection = cycleHelper.mBarAnalyser.IsRejectionBar( - pBar, - pBarRejectionDir // - ); - - // - // Engulf Bar ... - ENUM_X_DIRECTION pBarEngulfDir; - bool isPBarEngulf = cycleHelper.mBarAnalyser.IsEngulfBar( - pBar, - pBarEngulfDir // - ); - - // - // Pin Bar ... - ENUM_X_DIRECTION pBarPinDir; - bool isPBarPin = cycleHelper.mBarAnalyser.IsPinBar( - pBar, - pBarPinDir // - ); - - // - bool isBullish = false; - bool isBearish = false; - - // - if (forProvider == X_121_SMC_PROVIDER_VWAPC) - { - // - isBullish = - // - // pBar is Pin and cBar is Momentum or Rejection or Engulf - ( - // - (isPBarPin && - IsBullish(pBarPinDir) && - ( - // - (isCBarMomentum && - IsBullish(cBarMomentumDir)) - // - || - // - (isCBarRejection && - IsBullish(cBarRejectionDir)) - // - || - // - (isCBarEngulf && - IsBullish(cBarEngulfDir)) - // - ) - // - ) - // - || - // - // pBar is Engulf and cBar is Momentum or Rejection or Pin ... - (isPBarEngulf && - IsBullish(pBarEngulfDir) && - ( - // - (isCBarMomentum && - IsBullish(cBarMomentumDir)) - // - || - // - (isCBarRejection && - IsBullish(cBarRejectionDir)) - // - || - // - (isCBarPin && - IsBullish(cBarPinDir)) - // - ) - // - ) - // - || - // - // pBar is Rejection and cBar is Momentum or Engulf or Pin ... - (isPBarRejection && - IsBullish(pBarRejectionDir) && - ( - // - (isCBarMomentum && - IsBullish(cBarMomentumDir)) - // - || - // - (isCBarEngulf && - IsBullish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBullish(cBarPinDir)) - // - ) - // - ) - // - || - // - // pBar is Momentum and cBar is Rejection or Engulf or Pin ... - (isPBarMomentum && - IsBullish(pBarMomentumDir) && - ( - // - (isCBarRejection && - IsBullish(cBarRejectionDir)) - // - || - // - (isCBarEngulf && - IsBullish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBullish(cBarPinDir)) - // - ) - // - ) - // - || - // - // cBar is Pin and Momentum and Rejection and Engulf ... - ( - // - (isCBarPin && - IsBullish(cBarPinDir)) - // - && - // - (isCBarMomentum && - IsBullish(cBarMomentumDir)) - // - && - // - (isCBarRejection && - IsBullish(cBarRejectionDir)) - // - && - // - (isCBarEngulf && - IsBullish(cBarEngulfDir)) - // - ) - // - ) - // - ; - - // - isBearish = - // - // pBar is Pin and cBar is Momentum or Rejection or Engulf - ( - // - (isPBarPin && - IsBearish(pBarPinDir) && - ( - // - (isCBarMomentum && - IsBearish(cBarMomentumDir)) - // - || - // - (isCBarRejection && - IsBearish(cBarRejectionDir)) - // - || - // - (isCBarEngulf && - IsBearish(cBarEngulfDir)) - // - ) - // - ) - // - || - // - // pBar is Engulf and cBar is Momentum or Rejection or Pin ... - (isPBarEngulf && - IsBearish(pBarEngulfDir) && - ( - // - (isCBarMomentum && - IsBearish(cBarMomentumDir)) - // - || - // - (isCBarRejection && - IsBearish(cBarRejectionDir)) - // - || - // - (isCBarPin && - IsBearish(cBarPinDir)) - // - ) - // - ) - // - || - // - // pBar is Rejection and cBar is Momentum or Engulf or Pin ... - (isPBarRejection && - IsBearish(pBarRejectionDir) && - ( - // - (isCBarMomentum && - IsBearish(cBarMomentumDir)) - // - || - // - (isCBarEngulf && - IsBearish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBearish(cBarPinDir)) - // - ) - // - ) - // - || - // - // pBar is Momentum and cBar is Rejection or Engulf or Pin ... - (isPBarMomentum && - IsBearish(pBarMomentumDir) && - ( - // - (isCBarRejection && - IsBearish(cBarRejectionDir)) - // - || - // - (isCBarEngulf && - IsBearish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBearish(cBarPinDir)) - // - ) - // - ) - // - || - // - // cBar is Pin and Momentum and Rejection and Engulf ... - ( - // - (isCBarPin && - IsBearish(cBarPinDir)) - // - && - // - (isCBarMomentum && - IsBearish(cBarMomentumDir)) - // - && - // - (isCBarRejection && - IsBearish(cBarRejectionDir)) - // - && - // - (isCBarEngulf && - IsBearish(cBarEngulfDir)) - // - ) - // - ) - // - ; - } - - // - if (forProvider == X_121_SMC_PROVIDER_RJBPV) - { - // - isBullish = - // - // CBar is Pin, Engulf, Momentum or Rejection ... - ( - // // - // (isCBarMomentum && - // IsBullish(cBarMomentumDir)) - // // - // || - // // - (isCBarRejection && - IsBullish(cBarRejectionDir)) - // // - // || - // // - // (isCBarEngulf && - // IsBullish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBullish(cBarPinDir)) - // - ) - // - ; - - // - isBearish = - // - // CBar is Pin, Engulf, Momentum or Rejection ... - ( - // - // (isCBarMomentum && - // IsBearish(cBarMomentumDir)) - // // - // || - // // - (isCBarRejection && - IsBearish(cBarRejectionDir)) - // // - // || - // // - // (isCBarEngulf && - // IsBearish(cBarEngulfDir)) - // - || - // - (isCBarPin && - IsBearish(cBarPinDir)) - // - ) - // - ; - } - - // - result = isBullish || - isBearish; - if (!result) - { - return result; - } - - // - dir = - isBullish - ? X_DIRECTION_BULLISH - : X_DIRECTION_BEARISH; + // mTestConditions.Clean(); // return result;